home *** CD-ROM | disk | FTP | other *** search
/ Amiga Format CD 38 / Amiga Format CD38 (1999-03-15)(Future Publishing)(GB)(Track 1 of 3)[!][issue 1999-04].iso / -seriously_amiga- / programming / other / cyberxxxsrc / decoder / txt / decodejpeg.c < prev    next >
C/C++ Source or Header  |  1999-02-08  |  97KB  |  3,005 lines
  1. /*
  2. sc:c/sc opt txt/DecodeJPEG.c
  3. */
  4.  
  5. #include "Decode.h"
  6. #include "YUV.h"
  7. #include "Utils.h"
  8. #include "GlobalVars.h"
  9. #include "JPEG.h"
  10.  
  11. /* /// "define's und Variablen" */
  12. ulong bytes_pixel;
  13. extern long xa_dither_flag;
  14.  
  15. uchar  *jpg_buff = 0;
  16. long  jpg_bsize = 0;
  17.  
  18. long   jpg_h_bnum;
  19. ulong  jpg_h_bbuf;
  20.  
  21. long   *jpg_quant_tables[JJ_NUM_QUANT_TBLS];
  22. ulong  jpg_marker = 0;
  23. ulong  jpg_saw_SOI,jpg_saw_SOF,jpg_saw_SOS;
  24. ulong  jpg_saw_DHT,jpg_saw_DQT,jpg_saw_EOI;
  25. ulong  jpg_std_DHT_flag = 0;
  26. long   jpg_dprec,jpg_height,jpg_width;
  27. long   jpg_num_comps,jpg_comps_in_scan;
  28. long   jpg_nxt_rst_num;
  29. long   jpg_rst_interval;
  30.  
  31. ulong xa_mjpg_kludge;
  32.  
  33. JJ_HUFF_TBL jpg_ac_huff[JJ_NUM_HUFF_TBLS];
  34. JJ_HUFF_TBL jpg_dc_huff[JJ_NUM_HUFF_TBLS];
  35.  
  36. COMPONENT_HDR jpg_comps[JPG_MAX_COMPS + 1];
  37.  
  38. long JJ_ZAG[DCTSIZE2+16] = {
  39.   0,  1,  8, 16,  9,  2,  3, 10,
  40.  17, 24, 32, 25, 18, 11,  4,  5,
  41.  12, 19, 26, 33, 40, 48, 41, 34,
  42.  27, 20, 13,  6,  7, 14, 21, 28,
  43.  35, 42, 49, 56, 57, 50, 43, 36,
  44.  29, 22, 15, 23, 30, 37, 44, 51,
  45.  58, 59, 52, 45, 38, 31, 39, 46,
  46.  53, 60, 61, 54, 47, 55, 62, 63,
  47.   0,  0,  0,  0,  0,  0,  0,  0,
  48.   0,  0,  0,  0,  0,  0,  0,  0
  49. };
  50.  
  51. ulong jpg_MCUbuf_size = 0;
  52. uchar *jpg_Ybuf = 0;
  53. uchar *jpg_Ubuf = 0;
  54. uchar *jpg_Vbuf = 0;
  55. short jpg_dct_buf[DCTSIZE2];
  56. /* \\\ */
  57.  
  58. struct JPEGData {
  59.   long *quantTab[JJ_NUM_QUANT_TBLS];
  60. };
  61.  
  62. struct JPEGData *JPGData;
  63.  
  64. /* /// "proto-types" */
  65. ulong jpg_decode_111111(uchar *image, ulong width, ulong height, ulong interleave, ulong row_offset, ulong imagex, ulong imagey, ulong gray);
  66. ulong jpg_decode_211111(uchar *image, ulong width, ulong height, ulong interleave, ulong row_offset, ulong imagex, ulong imagey);
  67. ulong jpg_decode_221111(uchar *image, ulong width, ulong height, ulong interleave, ulong row_offset, ulong imagex, ulong imagey);
  68. ulong jpg_decode_411111(uchar *image, ulong width, ulong height, ulong interleave, ulong row_offset, ulong imagex, ulong imagey);
  69. void __regargs (*mcu111111) (uchar *to, ulong width, ulong height, ulong rowSize, ulong ipSize);
  70. void __regargs (*mcu211111) (uchar *to, ulong width, ulong height, ulong rowSize, ulong ipSize);
  71. void __regargs (*mcu221111) (uchar *to, ulong width, ulong height, ulong rowSize, ulong ipSize);
  72. void __regargs (*mcu411111) (uchar *to, ulong width, ulong height, ulong rowSize, ulong ipSize);
  73. void jpg_huff_build(JJ_HUFF_TBL *htbl, uchar *hbits, uchar *hvals);
  74. ulong jpg_huffparse(register COMPONENT_HDR *comp, register short *dct_buf, ulong *qtab, uchar *OBuf);
  75. void j_rev_dct (short *data, uchar *outptr, uchar *rnglimit);
  76. void JPG_Setup_Samp_Limit_Table();
  77. void JPG_Free_Samp_Limit_Table();
  78. ulong jpg_std_DHT(void);
  79. ulong jpg_search_marker(ulong marker, uchar **data_ptr, long *data_size);
  80. ulong jpg_read_SOI(void);
  81. ulong jpg_read_SOF(void);
  82. ulong jpg_read_SOS(void);
  83. ulong jpg_read_DQT(void);
  84. ulong jpg_read_DRI(void);
  85. ulong jpg_read_DHT(void);
  86. ulong jpg_skip_marker(void);
  87. ulong jpg_get_marker(void);
  88. ulong jpg_read_markers(void);
  89. ulong jpg_read_EOI_marker(void);
  90. ulong jpg_read_RST_marker(void);
  91. void jpg_init_input(uchar *buff, long buff_size);
  92. void jpg_huff_reset(void);
  93. /* \\\ */
  94.  
  95. /* /// "mcu1hInnerTail" */
  96. #define mcu1hInnerTail(inc1) { \
  97.   skip++;                      \
  98.   if (skip>=8) {               \
  99.     skip=0;                    \
  100.     yp+=inc1;                  \
  101.     up+=inc1;                  \
  102.     vp+=inc1;                  \
  103.   }                            \
  104. }
  105. /* \\\ */
  106.  
  107. /* /// "mcu2hInnerTail" */
  108. #define mcu2hInnerTail(inc1,inc2) { \
  109.   skip++;                           \
  110.   if (skip==4)                      \
  111.     yp+=inc1;                       \
  112.   else                              \
  113.     if (skip>=8) {                  \
  114.       skip=0;                       \
  115.       yp+=inc2;                     \
  116.       up+=inc1;                     \
  117.       vp+=inc1;                     \
  118.     }                               \
  119. }
  120. /* \\\ */
  121.  
  122. /* /// "mcu4hInnerTail" */
  123. #define mcu4hInnerTail(inc1,inc2) { \
  124.   skip++;                           \
  125.   if (skip>=8) {                    \
  126.     skip=0;                         \
  127.     yp+=inc2;                       \
  128.     up+=inc1;                       \
  129.     vp+=inc1;                       \
  130.   } else                            \
  131.     if (!(skip & 1)) yp+=inc1;      \
  132. }
  133. /* \\\ */
  134.  
  135. /* /// "MCU111111toRGB()" */
  136. void __regargs MCU111111toRGB(uchar *to,
  137.                               ulong width,
  138.                               ulong height,
  139.                               ulong rowSize,
  140.                               ulong ipSize)
  141. {
  142.   long *ubTab=yuvTab->ubTab;
  143.   long *vrTab=yuvTab->vrTab;
  144.   long *ugTab=yuvTab->ugTab;
  145.   long *vgTab=yuvTab->vgTab;
  146.   long *yTab=yuvTab->yTab;
  147.   uchar *yBuf=yuvBuf->yBuf;
  148.   uchar *uBuf=yuvBuf->uBuf;
  149.   uchar *vBuf=yuvBuf->vBuf;
  150.  
  151.   ipSize>>=2;
  152.   while (height>0) {
  153.     RGBTriple *iptr=(RGBTriple *)to;
  154.     uchar *yptr=yBuf;
  155.     uchar *uptr=uBuf;
  156.     uchar *vptr=vBuf;
  157.     ulong xi, yi, skip;
  158.     for (yi=0; yi<8; yi++) {
  159.       RGBTriple *ip=iptr;
  160.       uchar *yp=yptr;
  161.       uchar *up=uptr;
  162.       uchar *vp=vptr;
  163.       if (height<=0) return;
  164.       xi=width;
  165.       skip=0;
  166.       while (xi--) {
  167.         ulong u0=*up++;
  168.         ulong v0=*vp++;
  169.         long cr=vrTab[v0];
  170.         long cg=vgTab[v0]+ugTab[u0];
  171.         long cb=ubTab[u0];
  172.         iDecYUVRGB(ip[0],*yp++,cr,cg,cb);
  173.         mcu1hInnerTail(56);
  174.         ip++;
  175.       }
  176.       yptr+=8;
  177.       uptr+=8;
  178.       vptr+=8;
  179.       height--;
  180.       iptr+=ipSize;
  181.     }
  182.     yBuf+=rowSize;
  183.     uBuf+=rowSize;
  184.     vBuf+=rowSize;
  185.   }
  186. }
  187. /* \\\ */
  188.  
  189. /* /// "MCU111111to332()" */
  190. void __regargs MCU111111to332(uchar *to,
  191.                               ulong width,
  192.                               ulong height,
  193.                               ulong rowSize,
  194.                               ulong ipSize)
  195. {
  196.   long *ubTab=yuvTab->ubTab;
  197.   long *vrTab=yuvTab->vrTab;
  198.   long *ugTab=yuvTab->ugTab;
  199.   long *vgTab=yuvTab->vgTab;
  200.   long *yTab=yuvTab->yTab;
  201.   uchar *yBuf=yuvBuf->yBuf;
  202.   uchar *uBuf=yuvBuf->uBuf;
  203.   uchar *vBuf=yuvBuf->vBuf;
  204.  
  205.   while (height>0) {
  206.     uchar *iptr=(uchar *)to;
  207.     uchar *yptr=yBuf;
  208.     uchar *uptr=uBuf;
  209.     uchar *vptr=vBuf;
  210.     ulong xi, yi, skip;
  211.     for (yi=0; yi<8; yi++) {
  212.       uchar *ip=iptr;
  213.       uchar *yp=yptr;
  214.       uchar *up=uptr;
  215.       uchar *vp=vptr;
  216.       if (height<=0) return;
  217.       xi=width;
  218.       skip=0;
  219.       while (xi--) {
  220.         if (gray) {
  221.           *ip++=*yp++;
  222.         } else {
  223.           ulong u0=*up++;
  224.           ulong v0=*vp++;
  225.           long cr=vrTab[v0];
  226.           long cg=vgTab[v0]+ugTab[u0];
  227.           long cb=ubTab[u0];
  228.           DecYUV332(ip,*yp++,cr,cg,cb);
  229.         }
  230.         mcu1hInnerTail(56);
  231.       }
  232.       yptr+=8;
  233.       uptr+=8;
  234.       vptr+=8;
  235.       height--;
  236.       iptr+=ipSize;
  237.     }
  238.     yBuf+=rowSize;
  239.     uBuf+=rowSize;
  240.     vBuf+=rowSize;
  241.   }
  242. }
  243. /* \\\ */
  244.  
  245. /* /// "MCU111111to332Dith()" */
  246. void __regargs MCU111111to332Dith(uchar *to,
  247.                                   ulong width,
  248.                                   ulong height,
  249.                                   ulong rowSize,
  250.                                   ulong ipSize)
  251. {
  252.   long *ubTab=yuvTab->ubTab;
  253.   long *vrTab=yuvTab->vrTab;
  254.   long *ugTab=yuvTab->ugTab;
  255.   long *vgTab=yuvTab->vgTab;
  256.   long *yTab=yuvTab->yTab;
  257.   uchar *yBuf=yuvBuf->yBuf;
  258.   uchar *uBuf=yuvBuf->uBuf;
  259.   uchar *vBuf=yuvBuf->vBuf;
  260.  
  261.   while (height>0) {
  262.     uchar *iptr=(uchar *)to;
  263.     uchar *yptr=yBuf;
  264.     uchar *uptr=uBuf;
  265.     uchar *vptr=vBuf;
  266.     ulong xi, yi, skip;
  267.     for (yi=0; yi<8; yi++) {
  268.       uchar *ip=iptr;
  269.       uchar *yp=yptr;
  270.       uchar *up=uptr;
  271.       uchar *vp=vptr;
  272.       long re=0, ge=0, be=0;
  273.       if (height<=0) return;
  274.       xi=width;
  275.       skip=0;
  276.       while (xi--) {
  277.         ulong u0=*up++;
  278.         ulong v0=*vp++;
  279.         long cr=vrTab[v0];
  280.         long cg=vgTab[v0]+ugTab[u0];
  281.         long cb=ubTab[u0];
  282.         DecYUV332Dith(*ip++,*yp++,cr,cg,cb);
  283.         mcu1hInnerTail(56);
  284.       }
  285.       yptr+=8;
  286.       uptr+=8;
  287.       vptr+=8;
  288.       height--;
  289.       iptr+=ipSize;
  290.     }
  291.     yBuf+=rowSize;
  292.     uBuf+=rowSize;
  293.     vBuf+=rowSize;
  294.   }
  295. }
  296. /* \\\ */
  297.  
  298. /* /// "MCU111111toGray()" */
  299. void __regargs MCU111111toGray(uchar *to,
  300.                                ulong width,
  301.                                ulong height,
  302.                                ulong rowSize,
  303.                                ulong ipSize)
  304. {
  305.   uchar *yBuf=yuvBuf->yBuf;
  306.  
  307.   while (height>0) {
  308.     uchar *iptr=(uchar *)to;
  309.     uchar *yptr=yBuf;
  310.     ulong xi, yi, skip;
  311.     for (yi=0; yi<8; yi++) {
  312.       uchar *ip=iptr;
  313.       uchar *yp=yptr;
  314.       if (height<=0) return;
  315.       xi=width;
  316.       skip=0;
  317.       while (xi--) {
  318.         *ip++=*yp++;
  319.         skip++;
  320.         if (skip>=8) {skip=0; yp+=56; }
  321.       }
  322.       yptr+=8;
  323.       height--;
  324.       iptr+=ipSize;
  325.     }
  326.     yBuf+=rowSize;
  327.   }
  328. }
  329. /* \\\ */
  330.  
  331. /* /// "MCU211111toRGB()" */
  332. void __regargs MCU211111toRGB(uchar *to,
  333.                               ulong width,
  334.                               ulong height,
  335.                               ulong rowSize,
  336.                               ulong ipSize)
  337. {
  338.   long *ubTab=yuvTab->ubTab;
  339.   long *vrTab=yuvTab->vrTab;
  340.   long *ugTab=yuvTab->ugTab;
  341.   long *vgTab=yuvTab->vgTab;
  342.   long *yTab=yuvTab->yTab;
  343.   uchar *yBuf=yuvBuf->yBuf;
  344.   uchar *uBuf=yuvBuf->uBuf;
  345.   uchar *vBuf=yuvBuf->vBuf;
  346.  
  347.   ipSize>>=2;
  348.   while (height>0) {
  349.     RGBTriple *iptr=(RGBTriple *)to;
  350.     uchar *yptr=yBuf;
  351.     uchar *uptr=uBuf;
  352.     uchar *vptr=vBuf;
  353.     ulong xi, yi, skip;
  354.     for (yi=0; yi<8; yi++) {
  355.       RGBTriple *ip=iptr;
  356.       uchar *yp=yptr;
  357.       uchar *up=uptr;
  358.       uchar *vp=vptr;
  359.       if (height<=0) return;
  360.       xi=width;
  361.       skip=0;
  362.       while (xi--) {
  363.         ulong u0=*up++;
  364.         ulong v0=*vp++;
  365.         long cr=vrTab[v0];
  366.         long cg=vgTab[v0]+ugTab[u0];
  367.         long cb=ubTab[u0];
  368.         iDecYUVRGB(ip[0],*yp++,cr,cg,cb);
  369.         iDecYUVRGB(ip[1],*yp++,cr,cg,cb);
  370.         mcu2hInnerTail(56,56);
  371.         ip+=2;
  372.       }
  373.       yptr+=8;
  374.       uptr+=8;
  375.       vptr+=8;
  376.       height--;
  377.       iptr+=ipSize;
  378.     }
  379.     yBuf+=rowSize<<1;
  380.     uBuf+=rowSize;
  381.     vBuf+=rowSize;
  382.   }
  383. }
  384. /* \\\ */
  385.  
  386. /* /// "MCU211111to332()" */
  387. void __regargs MCU211111to332(uchar *to,
  388.                               ulong width,
  389.                               ulong height,
  390.                               ulong rowSize,
  391.                               ulong ipSize)
  392. {
  393.   long *ubTab=yuvTab->ubTab;
  394.   long *vrTab=yuvTab->vrTab;
  395.   long *ugTab=yuvTab->ugTab;
  396.   long *vgTab=yuvTab->vgTab;
  397.   long *yTab=yuvTab->yTab;
  398.   uchar *yBuf=yuvBuf->yBuf;
  399.   uchar *uBuf=yuvBuf->uBuf;
  400.   uchar *vBuf=yuvBuf->vBuf;
  401.  
  402.   while (height>0) {
  403.     uchar *iptr=(uchar *)to;
  404.     uchar *yptr=yBuf;
  405.     uchar *uptr=uBuf;
  406.     uchar *vptr=vBuf;
  407.     ulong xi, yi, skip;
  408.     for (yi=0; yi<8; yi++) {
  409.       uchar *ip=iptr;
  410.       uchar *yp=yptr;
  411.       uchar *up=uptr;
  412.       uchar *vp=vptr;
  413.       if (height<=0) return;
  414.       xi=width;
  415.       skip=0;
  416.       while (xi--) {
  417.         if (gray) {
  418.           ip[0]=yp[0];
  419.           ip[1]=yp[1];
  420.           ip+=2;
  421.           yp+=2;
  422.         } else {
  423.           ulong u0=*up++;
  424.           ulong v0=*vp++;
  425.           long cr=vrTab[v0];
  426.           long cg=vgTab[v0]+ugTab[u0];
  427.           long cb=ubTab[u0];
  428.           DecYUV332(ip,*yp++,cr,cg,cb);
  429.           DecYUV332(ip,*yp++,cr,cg,cb);
  430.         }
  431.         mcu2hInnerTail(56,56);
  432.       }
  433.       yptr+=8;
  434.       uptr+=8;
  435.       vptr+=8;
  436.       height--;
  437.       iptr+=ipSize;
  438.     }
  439.     yBuf+=rowSize<<1;
  440.     uBuf+=rowSize;
  441.     vBuf+=rowSize;
  442.   }
  443. }
  444. /* \\\ */
  445.  
  446. /* /// "MCU211111to332Dith()" */
  447. void __regargs MCU211111to332Dith(uchar *to,
  448.                                   ulong width,
  449.                                   ulong height,
  450.                                   ulong rowSize,
  451.                                   ulong ipSize)
  452. {
  453.   long *ubTab=yuvTab->ubTab;
  454.   long *vrTab=yuvTab->vrTab;
  455.   long *ugTab=yuvTab->ugTab;
  456.   long *vgTab=yuvTab->vgTab;
  457.   long *yTab=yuvTab->yTab;
  458.   uchar *yBuf=yuvBuf->yBuf;
  459.   uchar *uBuf=yuvBuf->uBuf;
  460.   uchar *vBuf=yuvBuf->vBuf;
  461.  
  462.   while (height>0) {
  463.     uchar *iptr=(uchar *)to;
  464.     uchar *yptr=yBuf;
  465.     uchar *uptr=uBuf;
  466.     uchar *vptr=vBuf;
  467.     ulong xi, yi, skip;
  468.     for (yi=0; yi<8; yi++) {
  469.       uchar *ip=iptr;
  470.       uchar *yp=yptr;
  471.       uchar *up=uptr;
  472.       uchar *vp=vptr;
  473.       long re=0, ge=0, be=0;
  474.       if (height<=0) return;
  475.       xi=width;
  476.       skip=0;
  477.       while (xi--) {
  478.         ulong u0=*up++;
  479.         ulong v0=*vp++;
  480.         long cr=vrTab[v0];
  481.         long cg=vgTab[v0]+ugTab[u0];
  482.         long cb=ubTab[u0];
  483.         DecYUV332Dith(*ip++,*yp++,cr,cg,cb);
  484.         DecYUV332Dith(*ip++,*yp++,cr,cg,cb);
  485.         mcu2hInnerTail(56,56);
  486.       }
  487.       yptr+=8;
  488.       uptr+=8;
  489.       vptr+=8;
  490.       height--;
  491.       iptr+=ipSize;
  492.     }
  493.     yBuf+=rowSize<<1;
  494.     uBuf+=rowSize;
  495.     vBuf+=rowSize;
  496.   }
  497. }
  498. /* \\\ */
  499.  
  500. /* /// "MCU221111toRGB()" */
  501. void __regargs MCU221111toRGB(uchar *to,
  502.                               ulong width,
  503.                               ulong height,
  504.                               ulong rowSize,
  505.                               ulong ipSize)
  506. {
  507.   long *ubTab=yuvTab->ubTab;
  508.   long *vrTab=yuvTab->vrTab;
  509.   long *ugTab=yuvTab->ugTab;
  510.   long *vgTab=yuvTab->vgTab;
  511.   long *yTab=yuvTab->yTab;
  512.   uchar *yBuf=yuvBuf->yBuf;
  513.   uchar *uBuf=yuvBuf->uBuf;
  514.   uchar *vBuf=yuvBuf->vBuf;
  515.  
  516.   ipSize>>=2;
  517.   while (height>0) {
  518.     RGBTriple *iptr=(RGBTriple *)to;
  519.     uchar *yptr=yBuf;
  520.     uchar *uptr=uBuf;
  521.     uchar *vptr=vBuf;
  522.     ulong xi, yi, skip;
  523.     for (yi=0; yi<8; yi++) {
  524.       RGBTriple *ip0, *ip1;
  525.       uchar *yp, *up, *vp;
  526.       if (height<=0) return;
  527.       if (yi==4) yptr+=64;
  528.       yp=yptr; up=uptr; vp=vptr;
  529.       ip0=iptr;
  530.       iptr+=ipSize;
  531.       ip1=iptr;
  532.       iptr+=ipSize;
  533.       xi=width;
  534.       skip=0;
  535.       while (xi--) {
  536.         ulong u0=*up++;
  537.         ulong v0=*vp++;
  538.         long cr=vrTab[v0];
  539.         long cg=vgTab[v0]+ugTab[u0];
  540.         long cb=ubTab[u0];
  541.         iDecYUVRGB(ip1[0],yp[8],cr,cg,cb);
  542.         iDecYUVRGB(ip0[0],*yp++,cr,cg,cb);
  543.         iDecYUVRGB(ip1[1],yp[8],cr,cg,cb);
  544.         iDecYUVRGB(ip0[1],*yp++,cr,cg,cb);
  545.         mcu2hInnerTail(56,184);
  546.         ip0+=2;
  547.         ip1+=2;
  548.       }
  549.       yptr+=16;
  550.       uptr+=8;
  551.       vptr+=8;
  552.       height-=2;
  553.     }
  554.     yBuf+=rowSize<<2;
  555.     uBuf+=rowSize;
  556.     vBuf+=rowSize;
  557.   }
  558. }
  559. /* \\\ */
  560.  
  561. /* /// "MCU221111to332()" */
  562. void __regargs MCU221111to332(uchar *to,
  563.                               ulong width,
  564.                               ulong height,
  565.                               ulong rowSize,
  566.                               ulong ipSize)
  567. {
  568.   long *ubTab=yuvTab->ubTab;
  569.   long *vrTab=yuvTab->vrTab;
  570.   long *ugTab=yuvTab->ugTab;
  571.   long *vgTab=yuvTab->vgTab;
  572.   long *yTab=yuvTab->yTab;
  573.   uchar *yBuf=yuvBuf->yBuf;
  574.   uchar *uBuf=yuvBuf->uBuf;
  575.   uchar *vBuf=yuvBuf->vBuf;
  576.  
  577.   while (height>0) {
  578.     uchar *iptr=(uchar *)to;
  579.     uchar *yptr=yBuf;
  580.     uchar *uptr=uBuf;
  581.     uchar *vptr=vBuf;
  582.     ulong xi, yi, skip;
  583.     for (yi=0; yi<8; yi++) {
  584.       uchar *ip0, *ip1;
  585.       uchar *yp, *up, *vp;
  586.       if (height<=0) return;
  587.       if (yi==4) yptr+=64;
  588.       yp=yptr; up=uptr; vp=vptr;
  589.       ip0=iptr;
  590.       iptr+=ipSize;
  591.       ip1=iptr;
  592.       iptr+=ipSize;
  593.       xi=width;
  594.       skip=0;
  595.       while (xi--) {
  596.         if (gray) {
  597.           *ip1++=yp[8];
  598.           *ip0++=*yp++;
  599.           *ip1++=yp[8];
  600.           *ip0++=*yp++;
  601.         } else {
  602.           ulong u0=*up++;
  603.           ulong v0=*vp++;
  604.           long cr=vrTab[v0];
  605.           long cg=vgTab[v0]+ugTab[u0];
  606.           long cb=ubTab[u0];
  607.           DecYUV332(ip1,yp[8],cr,cg,cb);
  608.           DecYUV332(ip0,*yp++,cr,cg,cb);
  609.           DecYUV332(ip1,yp[8],cr,cg,cb);
  610.           DecYUV332(ip0,*yp++,cr,cg,cb);
  611.         }
  612.         mcu2hInnerTail(56,184);
  613.       }
  614.       yptr+=16;
  615.       uptr+=8;
  616.       vptr+=8;
  617.       height-=2;
  618.     }
  619.     yBuf+=rowSize<<2;
  620.     uBuf+=rowSize;
  621.     vBuf+=rowSize;
  622.   }
  623. }
  624. /* \\\ */
  625.  
  626. /* /// "MCU221111to332Dith()" */
  627. void __regargs MCU221111to332Dith(uchar *to,
  628.                                   ulong width,
  629.                                   ulong height,
  630.                                   ulong rowSize,
  631.                                   ulong ipSize)
  632. {
  633.   long *ubTab=yuvTab->ubTab;
  634.   long *vrTab=yuvTab->vrTab;
  635.   long *ugTab=yuvTab->ugTab;
  636.   long *vgTab=yuvTab->vgTab;
  637.   long *yTab=yuvTab->yTab;
  638.   uchar *yBuf=yuvBuf->yBuf;
  639.   uchar *uBuf=yuvBuf->uBuf;
  640.   uchar *vBuf=yuvBuf->vBuf;
  641.  
  642.   while (height>0) {
  643.     uchar *iptr=(uchar *)to;
  644.     uchar *yptr=yBuf;
  645.     uchar *uptr=uBuf;
  646.     uchar *vptr=vBuf;
  647.     ulong xi, yi, skip;
  648.     for (yi=0; yi<8; yi++) {
  649.       uchar *ip0, *ip1;
  650.       uchar *yp, *up, *vp;
  651.       long re=0, ge=0, be=0;
  652.       if (height<=0) return;
  653.       if (yi==4) yptr+=64;
  654.       yp=yptr; up=uptr; vp=vptr;
  655.       ip0=iptr;
  656.       iptr+=ipSize;
  657.       ip1=iptr;
  658.       iptr+=ipSize;
  659.       xi=width;
  660.       skip=0;
  661.       while (xi--) {
  662.         ulong u0=*up++;
  663.         ulong v0=*vp++;
  664.         long cr=vrTab[v0];
  665.         long cg=vgTab[v0]+ugTab[u0];
  666.         long cb=ubTab[u0];
  667.         DecYUV332Dith(*ip1++,yp[8],cr,cg,cb);
  668.         DecYUV332Dith(*ip0++,*yp++,cr,cg,cb);
  669.         DecYUV332Dith(*ip1++,yp[8],cr,cg,cb);
  670.         DecYUV332Dith(*ip0++,*yp++,cr,cg,cb);
  671.         mcu2hInnerTail(56,184);
  672.       }
  673.       yptr+=16;
  674.       uptr+=8;
  675.       vptr+=8;
  676.       height-=2;
  677.     }
  678.     yBuf+=rowSize<<2;
  679.     uBuf+=rowSize;
  680.     vBuf+=rowSize;
  681.   }
  682. }
  683. /* \\\ */
  684.  
  685. /* /// "MCU411111toRGB()" */
  686. void __regargs MCU411111toRGB(uchar *to,
  687.                               ulong width,
  688.                               ulong height,
  689.                               ulong rowSize,
  690.                               ulong ipSize)
  691. {
  692.   long *ubTab=yuvTab->ubTab;
  693.   long *vrTab=yuvTab->vrTab;
  694.   long *ugTab=yuvTab->ugTab;
  695.   long *vgTab=yuvTab->vgTab;
  696.   long *yTab=yuvTab->yTab;
  697.   uchar *yBuf=yuvBuf->yBuf;
  698.   uchar *uBuf=yuvBuf->uBuf;
  699.   uchar *vBuf=yuvBuf->vBuf;
  700.  
  701.   ipSize>>=2;
  702.   while (height>0) {
  703.     RGBTriple *iptr=(RGBTriple *)to;
  704.     uchar *yptr=yBuf;
  705.     uchar *uptr=uBuf;
  706.     uchar *vptr=vBuf;
  707.     ulong xi, yi, skip;
  708.     for (yi=0; yi<8; yi++) {
  709.       RGBTriple *ip=iptr;
  710.       uchar *yp=yptr;
  711.       uchar *up=uptr;
  712.       uchar *vp=vptr;
  713.       if (height<=0) return;
  714.       xi=width;
  715.       skip=0;
  716.       while (xi--) {
  717.         ulong u0=*up++;
  718.         ulong v0=*vp++;
  719.         long cr=vrTab[v0];
  720.         long cg=vgTab[v0]+ugTab[u0];
  721.         long cb=ubTab[u0];
  722.         iDecYUVRGB(ip[0],*yp++,cr,cg,cb);
  723.         iDecYUVRGB(ip[1],*yp++,cr,cg,cb);
  724.         iDecYUVRGB(ip[2],*yp++,cr,cg,cb);
  725.         iDecYUVRGB(ip[3],*yp++,cr,cg,cb);
  726.         mcu4hInnerTail(56,56);
  727.         ip+=4;
  728.       }
  729.       yptr+=8;
  730.       uptr+=8;
  731.       vptr+=8;
  732.       height--;
  733.       iptr+=ipSize;
  734.     }
  735.     yBuf+=rowSize<<2;
  736.     uBuf+=rowSize;
  737.     vBuf+=rowSize;
  738.   }
  739. }
  740. /* \\\ */
  741.  
  742. /* /// "MCU411111to332()" */
  743. void __regargs MCU411111to332(uchar *to,
  744.                               ulong width,
  745.                               ulong height,
  746.                               ulong rowSize,
  747.                               ulong ipSize)
  748. {
  749.   long *ubTab=yuvTab->ubTab;
  750.   long *vrTab=yuvTab->vrTab;
  751.   long *ugTab=yuvTab->ugTab;
  752.   long *vgTab=yuvTab->vgTab;
  753.   long *yTab=yuvTab->yTab;
  754.   uchar *yBuf=yuvBuf->yBuf;
  755.   uchar *uBuf=yuvBuf->uBuf;
  756.   uchar *vBuf=yuvBuf->vBuf;
  757.  
  758.   while (height>0) {
  759.     uchar *iptr=(uchar *)to;
  760.     uchar *yptr=yBuf;
  761.     uchar *uptr=uBuf;
  762.     uchar *vptr=vBuf;
  763.     ulong xi, yi, skip;
  764.     for (yi=0; yi<8; yi++) {
  765.       uchar *ip=iptr;
  766.       uchar *yp=yptr;
  767.       uchar *up=uptr;
  768.       uchar *vp=vptr;
  769.       if (height<=0) return;
  770.       xi=width;
  771.       skip=0;
  772.       while (xi--) {
  773.         if (gray) {
  774.           ip[0]=yp[0];
  775.           ip[1]=yp[1];
  776.           ip[2]=yp[2];
  777.           ip[3]=yp[3];
  778.           ip+=4;
  779.           yp+=4;
  780.         } else {
  781.           ulong u0=*up++;
  782.           ulong v0=*vp++;
  783.           long cr=vrTab[v0];
  784.           long cg=vgTab[v0]+ugTab[u0];
  785.           long cb=ubTab[u0];
  786.           DecYUV332(ip,*yp++,cr,cg,cb);
  787.           DecYUV332(ip,*yp++,cr,cg,cb);
  788.           DecYUV332(ip,*yp++,cr,cg,cb);
  789.           DecYUV332(ip,*yp++,cr,cg,cb);
  790.         }
  791.         mcu4hInnerTail(56,56);
  792.       }
  793.       yptr+=8;
  794.       uptr+=8;
  795.       vptr+=8;
  796.       height--;
  797.       iptr+=ipSize;
  798.     }
  799.     yBuf+=rowSize<<2;
  800.     uBuf+=rowSize;
  801.     vBuf+=rowSize;
  802.   }
  803. }
  804. /* \\\ */
  805.  
  806. /* /// "MCU411111to332Dith()" */
  807. void __regargs MCU411111to332Dith(uchar *to,
  808.                                   ulong width,
  809.                                   ulong height,
  810.                                   ulong rowSize,
  811.                                   ulong ipSize)
  812. {
  813.   long *ubTab=yuvTab->ubTab;
  814.   long *vrTab=yuvTab->vrTab;
  815.   long *ugTab=yuvTab->ugTab;
  816.   long *vgTab=yuvTab->vgTab;
  817.   long *yTab=yuvTab->yTab;
  818.   uchar *yBuf=yuvBuf->yBuf;
  819.   uchar *uBuf=yuvBuf->uBuf;
  820.   uchar *vBuf=yuvBuf->vBuf;
  821.  
  822.   while (height>0) {
  823.     uchar *iptr=(uchar *)to;
  824.     uchar *yptr=yBuf;
  825.     uchar *uptr=uBuf;
  826.     uchar *vptr=vBuf;
  827.     ulong xi, yi, skip;
  828.     for (yi=0; yi<8; yi++) {
  829.       uchar *ip=iptr;
  830.       uchar *yp=yptr;
  831.       uchar *up=uptr;
  832.       uchar *vp=vptr;
  833.       long re=0, ge=0, be=0;
  834.       if (height<=0) return;
  835.       xi=width;
  836.       skip=0;
  837.       while (xi--) {
  838.         ulong u0=*up++;
  839.         ulong v0=*vp++;
  840.         long cr=vrTab[v0];
  841.         long cg=vgTab[v0]+ugTab[u0];
  842.         long cb=ubTab[u0];
  843.         DecYUV332Dith(*ip++,*yp++,cr,cg,cb);
  844.         DecYUV332Dith(*ip++,*yp++,cr,cg,cb);
  845.         DecYUV332Dith(*ip++,*yp++,cr,cg,cb);
  846.         DecYUV332Dith(*ip++,*yp++,cr,cg,cb);
  847.         mcu4hInnerTail(56,56);
  848.       }
  849.       yptr+=8;
  850.       uptr+=8;
  851.       vptr+=8;
  852.       height--;
  853.       iptr+=ipSize;
  854.     }
  855.     yBuf+=rowSize<<2;
  856.     uBuf+=rowSize;
  857.     vBuf+=rowSize;
  858.   }
  859. }
  860. /* \\\ */
  861.  
  862. /* /// "jpg_read_SOI()" */
  863. ulong jpg_read_SOI()
  864. {
  865.   // DEBUG_LEVEL1 kprintf("SOI: \n");
  866.   jpg_rst_interval = 0;
  867.   return(xaTRUE);
  868. }
  869. /* \\\ */
  870.  
  871. /* /// "jpg_read_SOF()" */
  872. ulong jpg_read_SOF()
  873. {
  874.   long len,ci;
  875.   COMPONENT_HDR *comp;
  876.   
  877.   JJ_INPUT_xaSHORT(len);
  878.   if (xa_mjpg_kludge) len -= 6;
  879.   else len -= 8;
  880.  
  881.   JJ_INPUT_xaBYTE(jpg_dprec);
  882.   JJ_INPUT_xaSHORT(jpg_height);
  883.   JJ_INPUT_xaSHORT(jpg_width);
  884.   JJ_INPUT_xaBYTE(jpg_num_comps);
  885.  
  886.   // DEBUG_LEVEL1 kprintf("SOF: dprec %x res %d x %d comps %x\n",jpg_dprec,jpg_width,jpg_height,jpg_num_comps);
  887.  
  888.   for(ci = 0; ci < jpg_num_comps; ci++)
  889.   { ulong c;
  890.     if (ci > JPG_MAX_COMPS)     comp = &jpg_comps[JPG_DUMMY_COMP];
  891.     else                        comp = &jpg_comps[ci];
  892.     JJ_INPUT_xaBYTE(comp->id);
  893.     JJ_INPUT_xaBYTE(c);
  894.     comp->hvsample = c;
  895.     JJ_INPUT_xaBYTE(comp->qtbl_num);
  896.     // DEBUG_LEVEL1 kprintf("   id %x hvsamp %x qtbl %x\n",comp->id,c,comp->qtbl_num);
  897.   }
  898.   return (ulong)(JJ_INPUT_CHECK(0));
  899. }
  900. /* \\\ */
  901.  
  902. /* /// "jpg_read_SOS()" */
  903. ulong jpg_read_SOS()
  904. { long len,i;
  905.   long jpg_Ss, jpg_Se, jpg_AhAl;
  906.  
  907.   JJ_INPUT_xaSHORT(len);
  908.   /* if (xa_mjpg_kludge) len += 2; length ignored */
  909.  
  910.   JJ_INPUT_xaBYTE(jpg_comps_in_scan);
  911.  
  912.   for (i = 0; i < jpg_comps_in_scan; i++)
  913.   { long j,comp_id,htbl_num;
  914.     COMPONENT_HDR *comp = 0;
  915.  
  916.     JJ_INPUT_xaBYTE(comp_id);
  917.     j = 0;
  918.     while(j < jpg_num_comps)
  919.     { comp = &jpg_comps[j];
  920.       if (comp->id == comp_id) break;
  921.       j++;
  922.     }
  923.     if (j > jpg_num_comps) {
  924.       // kprintf("JJ: bad id %x",comp_id);
  925.       return(xaFALSE);
  926.     }
  927.  
  928.     JJ_INPUT_xaBYTE(htbl_num);
  929.     comp->dc_htbl_num = (htbl_num >> 4) & 0x0f;
  930.     comp->ac_htbl_num = (htbl_num     ) & 0x0f;
  931.     // DEBUG_LEVEL1 kprintf("     id %x dc/ac %x\n",comp_id,htbl_num);
  932.   }
  933.   JJ_INPUT_xaBYTE(jpg_Ss);
  934.   JJ_INPUT_xaBYTE(jpg_Se);
  935.   JJ_INPUT_xaBYTE(jpg_AhAl);
  936.   return (ulong)(JJ_INPUT_CHECK(0));
  937. }
  938. /* \\\ */
  939.  
  940. /* /// "jpg_read_DQT()" */
  941. ulong jpg_read_DQT()
  942. { long len;
  943.   JJ_INPUT_xaSHORT(len);
  944.   if ( !xa_mjpg_kludge ) len -= 2;
  945.  
  946.   // DEBUG_LEVEL1 kprintf("DQT:\n");
  947.  
  948.   while(len > 0)
  949.   { long i,tbl_num,prec;
  950.     long *quant_table;
  951.  
  952.     JJ_INPUT_xaBYTE(tbl_num);  len -= 1;
  953.     // DEBUG_LEVEL1 kprintf("     prec/tnum %02x\n",tbl_num);
  954.  
  955.     prec = (tbl_num >> 4) & 0x0f;
  956.     prec = (prec)?(2 * DCTSIZE2):(DCTSIZE2);  /* 128 or 64 */
  957.     tbl_num &= 0x0f;
  958.     if (tbl_num > 4) {
  959.       // kprintf("JJ: bad DQT tnum %x\n",tbl_num);
  960.       return(xaFALSE);
  961.     }
  962.  
  963. /*
  964.     if (jpg_quant_tables[tbl_num] == 0)
  965.     {
  966.       jpg_quant_tables[tbl_num] = (long *)malloc(64 * sizeof(long));
  967.       if (jpg_quant_tables[tbl_num] == 0)
  968.         { kprintf("JJ: DQT alloc err %x \n",tbl_num); return(xaFALSE); }
  969.     }
  970. */
  971.     len -= prec;
  972.     if (JJ_INPUT_CHECK(prec)==xaFALSE) return(xaFALSE);
  973.     quant_table = jpg_quant_tables[tbl_num];
  974.     if (prec==128)
  975.     { ulong tmp;
  976.       for (i = 0; i < DCTSIZE2; i++)
  977.         { JJ_INPUT_xaSHORT(tmp); quant_table[ JJ_ZAG[i] ] = (long) tmp; }
  978.     }
  979.     else
  980.     { ulong tmp;
  981.       for (i = 0; i < DCTSIZE2; i++)
  982.         { JJ_INPUT_xaBYTE(tmp); quant_table[ JJ_ZAG[i] ] = (long) tmp; }
  983.     }
  984.   }
  985.   return(xaTRUE);
  986. }
  987. /* \\\ */
  988.  
  989. /* /// "jpg_read_DRI()" */
  990. ulong jpg_read_DRI()
  991. { long len;
  992.   JJ_INPUT_xaSHORT(len);
  993.   JJ_INPUT_xaSHORT(jpg_rst_interval);
  994.   // DEBUG_LEVEL1 kprintf("DRI: int %x\n",jpg_rst_interval);
  995.   return(xaTRUE);
  996. }
  997. /* \\\ */
  998.  
  999. /* /// "jpg_skip_marker()" */
  1000. ulong jpg_skip_marker()
  1001. { long len,tmp;
  1002.   JJ_INPUT_xaSHORT(len); 
  1003.   // DEBUG_LEVEL1 kprintf("SKIP: marker %x len %x\n",jpg_marker,len);
  1004.   len -= 2; if (JJ_INPUT_CHECK(len)==xaFALSE) return(xaFALSE);
  1005.   while(len--) JJ_INPUT_xaBYTE(tmp); /* POD improve this */
  1006.   return(xaTRUE);
  1007. }
  1008. /* \\\ */
  1009.  
  1010. /* /// "jpg_read_DHT()" */
  1011. ulong jpg_read_DHT()
  1012. {
  1013.   long len;
  1014.   JJ_HUFF_TBL *htable;
  1015.   uchar  *hbits;
  1016.   uchar  *hvals;
  1017.  
  1018.   jpg_std_DHT_flag = 0;
  1019.   JJ_INPUT_xaSHORT(len);
  1020.   if (xa_mjpg_kludge) len += 2;
  1021.   len -= 2;
  1022.   if (JJ_INPUT_CHECK(len)==xaFALSE) return(xaFALSE);
  1023.  
  1024.   while(len > 0)
  1025.   { long i,index,count;
  1026.     JJ_INPUT_xaBYTE(index);
  1027.     /* POD index check */
  1028.     if (index & 0x10)                           /* AC Table */
  1029.     {
  1030.       index &= 0x0f;
  1031.       htable = &(jpg_ac_huff[index]);
  1032.       hbits  = jpg_ac_huff[index].bits;
  1033.       hvals  = jpg_ac_huff[index].vals;
  1034.     }
  1035.     else                                        /* DC Table */
  1036.     {
  1037.       htable = &(jpg_dc_huff[index]);
  1038.       hbits  = jpg_dc_huff[index].bits;
  1039.       hvals  = jpg_dc_huff[index].vals;
  1040.     }
  1041.     hbits[0] = 0;               count = 0;
  1042.     for (i = 1; i <= 16; i++)
  1043.     {
  1044.       JJ_INPUT_xaBYTE(hbits[i]);
  1045.       count += hbits[i];
  1046.     }
  1047.     len -= 17;
  1048.     if (count > 256) {
  1049.       // kprintf("JJ: DHT bad count %d\n",count);
  1050.       return(xaFALSE);
  1051.     }
  1052.  
  1053.     for (i = 0; i < count; i++) JJ_INPUT_xaBYTE(hvals[i]);
  1054.     len -= count;
  1055.  
  1056.     jpg_huff_build(htable,hbits,hvals);
  1057.  
  1058.   } /* end of len */
  1059.   return(xaTRUE);
  1060. }
  1061. /* \\\ */
  1062.  
  1063. /* /// "jpg_get_marker()" */
  1064. ulong jpg_get_marker()
  1065. {
  1066.   long c;
  1067.  
  1068.   for(;;)
  1069.   {
  1070.     JJ_INPUT_xaBYTE(c);
  1071.     while(c != 0xFF)    /* look for FF */
  1072.     {
  1073.       if (JJ_INPUT_CHECK(1)==xaFALSE) return(xaFALSE);
  1074.       JJ_INPUT_xaBYTE(c);
  1075.     }
  1076.     /* now we've got 1 0xFF, keep reading until next 0xFF */
  1077.     do
  1078.     {
  1079.       if (JJ_INPUT_CHECK(1)==xaFALSE) return(xaFALSE);
  1080.       JJ_INPUT_xaBYTE(c);
  1081.     } while (c == 0xFF);
  1082.     if (c != 0) break; /* ignore FF/00 sequences */
  1083.   }
  1084.   jpg_marker = c;
  1085.   return(xaTRUE);
  1086. }
  1087. /* \\\ */
  1088.  
  1089. /* /// "jpg_read_markers()" */
  1090. ulong jpg_read_markers()
  1091. {
  1092.   for(;;)
  1093.   { 
  1094.     if (jpg_get_marker() == xaFALSE) return(xaFALSE);
  1095.     // DEBUG_LEVEL1 kprintf("JJ: marker %x\n",jpg_marker);
  1096.     switch(jpg_marker)
  1097.     {
  1098.       case M_SOI: 
  1099.         if (jpg_read_SOI()==xaFALSE) return(xaFALSE);
  1100.         jpg_saw_SOI = xaTRUE;
  1101.         break;
  1102.       case M_SOF0: 
  1103.       case M_SOF1: 
  1104.         if (jpg_read_SOF()==xaFALSE) return(xaFALSE);
  1105.         jpg_saw_SOF = xaTRUE;
  1106.         break;
  1107.       case M_SOS: 
  1108.         if (jpg_read_SOS()==xaFALSE) return(xaFALSE);
  1109.         jpg_saw_SOS = xaTRUE;
  1110.         jpg_nxt_rst_num = 0;
  1111.         return(xaTRUE);
  1112.         break;
  1113.       case M_DHT:
  1114.         if (jpg_read_DHT()==xaFALSE) return(xaFALSE);
  1115.         jpg_saw_DHT = xaTRUE;
  1116.         break;
  1117.       case M_DQT:
  1118.         if (jpg_read_DQT()==xaFALSE) return(xaFALSE);
  1119.         jpg_saw_DQT = xaTRUE;
  1120.         break;
  1121.       case M_DRI:
  1122.         if (jpg_read_DRI()==xaFALSE) return(xaFALSE);
  1123.         break;
  1124.       case M_EOI:
  1125.         // kprintf("JJ: reached EOI without data\n");
  1126.         return(xaFALSE);
  1127.         break;
  1128.      case M_RST0:                /* these are all parameterless */
  1129.      case M_RST1:
  1130.      case M_RST2:
  1131.      case M_RST3:
  1132.      case M_RST4:
  1133.      case M_RST5:
  1134.      case M_RST6:
  1135.      case M_RST7:
  1136.      case M_TEM:
  1137.         break;
  1138.       default:
  1139.         if (jpg_skip_marker()==xaFALSE) return(xaFALSE);
  1140.         // DEBUG_LEVEL1 kprintf("JJ: skipped marker %x\n",jpg_marker);
  1141.         break;
  1142.     } /* end of switch */
  1143.   } /* end of forever */
  1144. }
  1145. /* \\\ */
  1146.  
  1147. /* /// "jpg_huff_build()" */
  1148. void jpg_huff_build(JJ_HUFF_TBL *htbl, uchar *hbits, uchar *hvals)
  1149. { ulong clen,num_syms,p,i,si,code,lookbits;
  1150.   ulong l,ctr;
  1151.   uchar huffsize[257];
  1152.   ulong huffcode[257];
  1153.  
  1154.   /*** generate code lengths for each symbol */
  1155.   num_syms = 0;
  1156.   for(clen = 1; clen <= 16; clen++)
  1157.   {
  1158.     for(i = 1; i <= (ulong)(hbits[clen]); i++)
  1159.                                 huffsize[num_syms++] = (uchar)(clen);
  1160.   }
  1161.   huffsize[num_syms] = 0;
  1162.  
  1163.   /*** generate codes */
  1164.   code = 0;
  1165.   si = huffsize[0];
  1166.   p = 0;
  1167.   while (huffsize[p])
  1168.   {
  1169.     while ( ((ulong)huffsize[p]) == si)
  1170.     {
  1171.       huffcode[p++] = code;
  1172.       code++;
  1173.     }
  1174.     code <<= 1;
  1175.     si++;
  1176.   }
  1177.  
  1178. /* Init mincode/maxcode/valptr arrays */
  1179.   p = 0;
  1180.   for (l = 1; l <= 16; l++) 
  1181.   {
  1182.     if (htbl->bits[l]) 
  1183.     {
  1184.       htbl->valptr[l] = p; /* huffval[] index of 1st symbol of code length l */
  1185.       htbl->mincode[l] = huffcode[p]; /* minimum code of length l */
  1186.       p += (ulong)(htbl->bits[l]);
  1187.       htbl->maxcode[l] = huffcode[p-1]; /* maximum code of length l */
  1188.     } 
  1189.     else
  1190.     {
  1191.       htbl->valptr[l] = 0;  /* not needed */
  1192.       htbl->mincode[l] = 0; /* not needed */
  1193.       htbl->maxcode[l] = 0; /* WAS -1; */   /* -1 if no codes of this length */
  1194.     }
  1195.   }
  1196.   htbl->maxcode[17] = 0xFFFFFL; /* ensures huff_DECODE terminates */
  1197.  
  1198.  
  1199. /* Init huffman cache */
  1200.   // memset((char *)htbl->cache, 0, ((1<<HUFF_LOOKAHEAD) * sizeof(xaUSHORT)) );
  1201.   // for (p=0; p<(1<<HUFF_LOOKAHEAD); p++) htbl->cache[p]=0;
  1202.   mymemset((ulong *)htbl->cache, 0, ((1<<HUFF_LOOKAHEAD) * sizeof(ushort)) );
  1203.  
  1204.   p = 0;
  1205.   for (l = 1; l <= HUFF_LOOKAHEAD; l++) 
  1206.   {
  1207.     for (i = 1; i <= (ulong) htbl->bits[l]; i++, p++)
  1208.     { short the_code = (ushort)((l << 8) | htbl->vals[p]);
  1209.  
  1210.       /* l = current code's length, p = its index in huffcode[] & huffval[]. */
  1211.       /* Generate left-justified code followed by all possible bit sequences */
  1212.  
  1213.       lookbits = huffcode[p] << (HUFF_LOOKAHEAD-l);
  1214.       for (ctr = 1 << (HUFF_LOOKAHEAD-l); ctr > 0; ctr--) 
  1215.       {
  1216.         htbl->cache[lookbits] = the_code;
  1217.         lookbits++;
  1218.       }
  1219.     }
  1220.   }
  1221. }
  1222. /* \\\ */
  1223.  
  1224. /* /// "jpg_init_input()" */
  1225. void jpg_init_input(uchar *buff, long buff_size)
  1226. {
  1227.   jpg_buff = buff;
  1228.   jpg_bsize = buff_size;
  1229. }
  1230. /* \\\ */
  1231.  
  1232. /* /// "jpg_huff_reset()" */
  1233. void jpg_huff_reset()
  1234. {
  1235.   jpg_comps[0].dc = 0;
  1236.   jpg_comps[1].dc = 0;
  1237.   jpg_comps[2].dc = 0;
  1238.   jpg_h_bbuf = 0;  /* clear huffman bit buffer */
  1239.   jpg_h_bnum = 0;
  1240. }
  1241. /* \\\ */
  1242.  
  1243. /* /// "jpg_read_EOI_marker()" */
  1244. ulong jpg_read_EOI_marker()
  1245. { 
  1246.   /* POD make sure previous code restores bit buffer to input stream */ 
  1247.   while( jpg_get_marker() == xaTRUE)
  1248.   {
  1249.     if (jpg_marker == M_EOI) {jpg_saw_EOI = xaTRUE; return(xaTRUE); }
  1250.   }
  1251.   return(xaFALSE);
  1252. }
  1253. /* \\\ */
  1254.  
  1255. /* /// "jpg_read_RST_marker()" */
  1256. ulong jpg_read_RST_marker()
  1257. {
  1258.   if ( (jpg_marker >= M_RST0) && (jpg_marker <= M_RST7) ) 
  1259.   {
  1260.     // DEBUG_LEVEL1 kprintf("JJ: RST marker %x found\n",jpg_marker);
  1261.     return(xaTRUE);
  1262.   }
  1263.   else
  1264.   {
  1265.     // kprintf("JJ: NON-restart marker found %x\n",jpg_marker);
  1266.     // kprintf("JJ: should resync-to-restart\n");
  1267.   }
  1268.   return(xaTRUE); /* POD NOTE just for now */
  1269. }
  1270. /* \\\ */
  1271.  
  1272. /* /// "define's" */
  1273. #define jpg_huff_EXTEND(val,sz) ((val) < (1<<((sz)-1)) ? (val) + (((-1)<<(sz)) + 1) : (val))
  1274.  
  1275. #define JJ_HBBUF_FILL8(hbbuf,hbnum) { \
  1276.   register ulong _tmp;                \
  1277.   hbbuf <<= 8;                        \
  1278.   if (jpg_marker)                     \
  1279.     return(xaFALSE);                  \
  1280.   else                                \
  1281.     JJ_INPUT_xaBYTE(_tmp);            \
  1282.   while(_tmp == 0xff) {               \
  1283.     register ulong _t1;               \
  1284.     JJ_INPUT_xaBYTE(_t1);             \
  1285.     if (_t1 == 0x00)                  \
  1286.       break;                          \
  1287.     else                              \
  1288.       if (_t1 == 0xff)                \
  1289.         continue;                     \
  1290.       else {                          \
  1291.         jpg_marker = _t1;             \
  1292.         _tmp = 0x00;                  \
  1293.         break;                        \
  1294.       }                               \
  1295.   }                                   \
  1296.   hbbuf |= _tmp;                      \
  1297.   hbnum += 8;                         \
  1298. }
  1299.  
  1300. #define JJ_HBBUF_FILL8_1(hbbuf,hbnum) { \
  1301.   register ulong __tmp;                 \
  1302.   hbbuf <<= 8;                          \
  1303.   hbnum += 8;                           \
  1304.   if (jpg_marker)                       \
  1305.     __tmp = 0x00;                       \
  1306.   else                                  \
  1307.     JJ_INPUT_xaBYTE(__tmp);             \
  1308.   while(__tmp == 0xff) {                \
  1309.     register ulong _t1;                 \
  1310.     JJ_INPUT_xaBYTE(_t1);               \
  1311.     if (_t1 == 0x00)                    \
  1312.       break;                            \
  1313.     else                                \
  1314.       if (_t1 == 0xff)                  \
  1315.         continue;                       \
  1316.       else {                            \
  1317.         jpg_marker = _t1;               \
  1318.         __tmp = 0x00;                   \
  1319.         break;                          \
  1320.       }                                 \
  1321.   }                                     \
  1322.   hbbuf |= __tmp;                       \
  1323. }
  1324.  
  1325. #define JJ_HUFF_DECODE(huff_hdr,htbl, hbnum, hbbuf, result) {           \
  1326.   register ulong _tmp, _hcode;                                          \
  1327.   while(hbnum < 16) JJ_HBBUF_FILL8_1(hbbuf,hbnum);                      \
  1328.   _tmp = (hbbuf >> (hbnum - 8)) & 0xff;                                 \
  1329.   _hcode = (htbl)[_tmp];                                                \
  1330.   if (_hcode) {                                                         \
  1331.     hbnum -= (_hcode >> 8);                                             \
  1332.     (result) = _hcode & 0xff;                                           \
  1333.   } else {                                                              \
  1334.     register ulong _hcode, _shift, _minbits = 9;                        \
  1335.     _tmp = (hbbuf >> (hbnum - 16)) & 0xffff; /* get 16 bits */          \
  1336.     _shift = 16 - _minbits;                                             \
  1337.     _hcode = _tmp >> _shift;                                            \
  1338.     while(_hcode > huff_hdr->maxcode[_minbits]) {                       \
  1339.       _minbits++;                                                       \
  1340.       _shift--;                                                         \
  1341.       _hcode = _tmp >> _shift;                                          \
  1342.     }                                                                   \
  1343.     if (_minbits > 16) {                                                \
  1344.       /* kprintf("JHDerr\n"); */                                        \
  1345.       return(xaFALSE);                                                  \
  1346.     } else {                                                            \
  1347.       hbnum -= _minbits;                                                \
  1348.       _hcode -= huff_hdr->mincode[_minbits];                            \
  1349.       result = huff_hdr->vals[ (huff_hdr->valptr[_minbits] + _hcode) ]; \
  1350.     }                                                                   \
  1351.   }                                                                     \
  1352. }
  1353.  
  1354. #define JJ_HUFF_MASK(s) ((1 << (s)) - 1)
  1355.  
  1356. #define JJ_GET_BITS(n, hbnum, hbbuf, result) {     \
  1357.   hbnum -= n;                                      \
  1358.   while(hbnum < 0) JJ_HBBUF_FILL8_1(hbbuf,hbnum);  \
  1359.   (result) = ((hbbuf >> hbnum) & JJ_HUFF_MASK(n)); \
  1360. }
  1361. /* \\\ */
  1362.  
  1363. /* /// "jpg_huffparse()" */
  1364. ulong jpg_huffparse(register COMPONENT_HDR *comp, register short *dct_buf, ulong *qtab, uchar *OBuf)
  1365. { long i,dcval;
  1366.   ulong size;
  1367.   JJ_HUFF_TBL *huff_hdr = &(jpg_dc_huff[ comp->dc_htbl_num ]);
  1368.   ushort *huff_tbl = huff_hdr->cache;
  1369.   uchar *limit = rngLimit + (CENTERJSAMPLE); // + MAXJSAMPLE + 1);
  1370.   ulong c_cnt,pos = 0;
  1371.  
  1372.   JJ_HUFF_DECODE(huff_hdr,huff_tbl,jpg_h_bnum,jpg_h_bbuf,size);
  1373.  
  1374.   // DEBUG_LEVEL2 kprintf(" HUFF DECODE: size %d\n",size);
  1375.  
  1376.   if (size)
  1377.   { ulong bits;
  1378.     JJ_GET_BITS(size,jpg_h_bnum,jpg_h_bbuf,bits);
  1379.     dcval = jpg_huff_EXTEND(bits, size);
  1380.     comp->dc += dcval;
  1381.     // DEBUG_LEVEL2 kprintf("   dcval %d  -dc %d\n",dcval,comp->dc);
  1382.   }
  1383.   dcval = comp->dc;
  1384.  
  1385.   /* clear reset of dct buffer */
  1386.   // memset((char *)(dct_buf),0,(DCTSIZE2 * sizeof(short)));
  1387.   // for (i=0; i<DCTSIZE2; i++) dct_buf[i]=0;
  1388.   mymemset((ulong *)(dct_buf),0,(DCTSIZE2 * sizeof(short)));
  1389.  
  1390.   dcval *= (long)qtab[0];
  1391.   dct_buf[0] = (short)dcval;
  1392.   c_cnt = 0;
  1393.  
  1394.   huff_hdr = &(jpg_ac_huff[ comp->ac_htbl_num ]);
  1395.   huff_tbl = huff_hdr->cache;
  1396.   i = 1;
  1397.   while(i < 64)
  1398.   { long level;       ulong run,tmp;
  1399.     JJ_HUFF_DECODE(huff_hdr,huff_tbl,jpg_h_bnum,jpg_h_bbuf,tmp); 
  1400.     size =  tmp & 0x0f;
  1401.     run = (tmp >> 4) & 0x0f; /* leading zeroes */
  1402.     // DEBUG_LEVEL2 kprintf("     %d) tmp %x size %x run %x\n",i,tmp,size,run);
  1403.     if (size)
  1404.     { long coeff;
  1405.       i += run; /* skip zeroes */
  1406.       JJ_GET_BITS(size, jpg_h_bnum,jpg_h_bbuf,level);
  1407.       coeff = (long)jpg_huff_EXTEND(level, size);
  1408.       // DEBUG_LEVEL2 kprintf("                   size %d coeff %x\n",size,coeff);
  1409.       pos = JJ_ZAG[i];
  1410.       coeff *= (long)qtab[ pos ];
  1411.       if (coeff)
  1412.       { c_cnt++;
  1413.         dct_buf[ pos ] = (short)(coeff);
  1414.       }
  1415.       i++;
  1416.     }
  1417.     else
  1418.     {
  1419.       if (run != 15) break; /* EOB */
  1420.       i += 16;
  1421.     }
  1422.   }
  1423.  
  1424.   if (c_cnt) j_rev_dct(dct_buf, OBuf, limit);
  1425.   else
  1426.   { register uchar *op = OBuf;
  1427.     register int jj = 8;
  1428.     short v = *dct_buf;
  1429.     register uchar dc;
  1430.     v = (v < 0)?( (v-3)>>3 ):( (v+4)>>3 );
  1431.     dc = limit[ (int) (v & RANGE_MASK) ];
  1432.     while(jj--)
  1433.     { op[0] = op[1] = op[2] = op[3] = op[4] = op[5] = op[6] = op[7] = dc;
  1434.       op += 8;
  1435.     }
  1436.   }
  1437.   return(xaTRUE);
  1438. }
  1439. /* \\\ */
  1440.  
  1441. /* /// "jpg_std_DHT()" */
  1442. ulong jpg_std_DHT()
  1443. {
  1444.   long ttt,len;
  1445.   JJ_HUFF_TBL *htable;
  1446.   uchar  *hbits,*Sbits;
  1447.   uchar  *hvals,*Svals;
  1448.  
  1449.   static uchar dc_luminance_bits[17] =
  1450.     { /* 0-base */ 0, 0, 1, 5, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0 };
  1451.   static uchar dc_luminance_vals[] =
  1452.     { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11 };
  1453.  
  1454.   static uchar dc_chrominance_bits[17] =
  1455.     { /* 0-base */ 0, 0, 3, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0 };
  1456.   static uchar dc_chrominance_vals[] =
  1457.     { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11 };
  1458.  
  1459.   static uchar ac_luminance_bits[17] =
  1460.     { /* 0-base */ 0, 0, 2, 1, 3, 3, 2, 4, 3, 5, 5, 4, 4, 0, 0, 1, 0x7d };
  1461.   static uchar ac_luminance_vals[] =
  1462.     { 0x01, 0x02, 0x03, 0x00, 0x04, 0x11, 0x05, 0x12,
  1463.       0x21, 0x31, 0x41, 0x06, 0x13, 0x51, 0x61, 0x07,
  1464.       0x22, 0x71, 0x14, 0x32, 0x81, 0x91, 0xa1, 0x08,
  1465.       0x23, 0x42, 0xb1, 0xc1, 0x15, 0x52, 0xd1, 0xf0,
  1466.       0x24, 0x33, 0x62, 0x72, 0x82, 0x09, 0x0a, 0x16,
  1467.       0x17, 0x18, 0x19, 0x1a, 0x25, 0x26, 0x27, 0x28,
  1468.       0x29, 0x2a, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39,
  1469.       0x3a, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49,
  1470.       0x4a, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59,
  1471.       0x5a, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69,
  1472.       0x6a, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78, 0x79,
  1473.       0x7a, 0x83, 0x84, 0x85, 0x86, 0x87, 0x88, 0x89,
  1474.       0x8a, 0x92, 0x93, 0x94, 0x95, 0x96, 0x97, 0x98,
  1475.       0x99, 0x9a, 0xa2, 0xa3, 0xa4, 0xa5, 0xa6, 0xa7,
  1476.       0xa8, 0xa9, 0xaa, 0xb2, 0xb3, 0xb4, 0xb5, 0xb6,
  1477.       0xb7, 0xb8, 0xb9, 0xba, 0xc2, 0xc3, 0xc4, 0xc5,
  1478.       0xc6, 0xc7, 0xc8, 0xc9, 0xca, 0xd2, 0xd3, 0xd4,
  1479.       0xd5, 0xd6, 0xd7, 0xd8, 0xd9, 0xda, 0xe1, 0xe2,
  1480.       0xe3, 0xe4, 0xe5, 0xe6, 0xe7, 0xe8, 0xe9, 0xea,
  1481.       0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7, 0xf8,
  1482.       0xf9, 0xfa };
  1483.  
  1484.   static uchar ac_chrominance_bits[17] =
  1485.     { /* 0-base */ 0, 0, 2, 1, 2, 4, 4, 3, 4, 7, 5, 4, 4, 0, 1, 2, 0x77 };
  1486.   static uchar ac_chrominance_vals[] =
  1487.     { 0x00, 0x01, 0x02, 0x03, 0x11, 0x04, 0x05, 0x21,
  1488.       0x31, 0x06, 0x12, 0x41, 0x51, 0x07, 0x61, 0x71,
  1489.       0x13, 0x22, 0x32, 0x81, 0x08, 0x14, 0x42, 0x91,
  1490.       0xa1, 0xb1, 0xc1, 0x09, 0x23, 0x33, 0x52, 0xf0,
  1491.       0x15, 0x62, 0x72, 0xd1, 0x0a, 0x16, 0x24, 0x34,
  1492.       0xe1, 0x25, 0xf1, 0x17, 0x18, 0x19, 0x1a, 0x26,
  1493.       0x27, 0x28, 0x29, 0x2a, 0x35, 0x36, 0x37, 0x38,
  1494.       0x39, 0x3a, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48,
  1495.       0x49, 0x4a, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58,
  1496.       0x59, 0x5a, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68,
  1497.       0x69, 0x6a, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78,
  1498.       0x79, 0x7a, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87,
  1499.       0x88, 0x89, 0x8a, 0x92, 0x93, 0x94, 0x95, 0x96,
  1500.       0x97, 0x98, 0x99, 0x9a, 0xa2, 0xa3, 0xa4, 0xa5,
  1501.       0xa6, 0xa7, 0xa8, 0xa9, 0xaa, 0xb2, 0xb3, 0xb4,
  1502.       0xb5, 0xb6, 0xb7, 0xb8, 0xb9, 0xba, 0xc2, 0xc3,
  1503.       0xc4, 0xc5, 0xc6, 0xc7, 0xc8, 0xc9, 0xca, 0xd2,
  1504.       0xd3, 0xd4, 0xd5, 0xd6, 0xd7, 0xd8, 0xd9, 0xda,
  1505.       0xe2, 0xe3, 0xe4, 0xe5, 0xe6, 0xe7, 0xe8, 0xe9,
  1506.       0xea, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7, 0xf8,
  1507.       0xf9, 0xfa };
  1508.  
  1509.   for(ttt=0;ttt<4;ttt++)
  1510.   { ulong index = ttt & 1;
  1511.     long i,count;
  1512.  
  1513.     if (ttt <= 1)  /* DC tables */ 
  1514.     {
  1515.       htable = &(jpg_dc_huff[index]);
  1516.       hbits  = jpg_dc_huff[index].bits;
  1517.       hvals  = jpg_dc_huff[index].vals;
  1518.         if (index==0) { Sbits = dc_luminance_bits; Svals = dc_luminance_vals; }
  1519.         else { Sbits = dc_chrominance_bits; Svals = dc_chrominance_vals; }
  1520.     }
  1521.     else /* AC tables */
  1522.     {
  1523.       htable = &(jpg_ac_huff[index]);
  1524.       hbits  = jpg_ac_huff[index].bits;
  1525.       hvals  = jpg_ac_huff[index].vals;
  1526.         if (index==0) { Sbits = ac_luminance_bits; Svals = ac_luminance_vals; }
  1527.         else { Sbits = ac_chrominance_bits; Svals = ac_chrominance_vals; }
  1528.     }
  1529.     hbits[0] = 0;               count = 0;
  1530.     for (i = 1; i <= 16; i++)
  1531.     {
  1532.       hbits[i] = Sbits[i];
  1533.       count += hbits[i];
  1534.     }
  1535.     // len -= 17;
  1536.     if (count > 256) {
  1537.       // kprintf("JJ: STD DHT bad count %d\n",count);
  1538.       return(xaFALSE);
  1539.     }
  1540.  
  1541.     for (i = 0; i < count; i++) hvals[i] = Svals[i];
  1542.     // len -= count;
  1543.  
  1544.     jpg_huff_build(htable,hbits,hvals);
  1545.  
  1546.   } /* end of i */
  1547.   jpg_std_DHT_flag = 1;
  1548.   return(xaTRUE);
  1549. }
  1550. /* \\\ */
  1551.  
  1552. /* /// "jpg_search_marker()" */
  1553. ulong jpg_search_marker(ulong marker, uchar **data_ptr, long *data_size)
  1554. { ulong d = 0;
  1555.   uchar *dptr = *data_ptr;
  1556.   long dsize = *data_size;
  1557.  
  1558.   while( dsize )
  1559.   {
  1560.     if (d == 0xff) /* potential marker */
  1561.     {
  1562.       d = *dptr++; dsize--;
  1563.       if (d == marker) 
  1564.       {
  1565.         *data_size = dsize; *data_ptr = dptr;   
  1566.         return(xaTRUE); /* found marker */
  1567.       }
  1568.     } else { d = *dptr++; dsize--; }
  1569.   }
  1570.   *data_size = dsize; *data_ptr = dptr;         
  1571.   return(xaFALSE);
  1572. }
  1573. /* \\\ */
  1574.  
  1575. /* /// "Tabellen und define's" */
  1576. char std_luminance_quant_tbl[64] = {
  1577.   16,  11,  12,  14,  12,  10,  16,  14,
  1578.   13,  14,  18,  17,  16,  19,  24,  40,
  1579.   26,  24,  22,  22,  24,  49,  35,  37,
  1580.   29,  40,  58,  51,  61,  60,  57,  51,
  1581.   56,  55,  64,  72,  92,  78,  64,  68,
  1582.   87,  69,  55,  56,  80, 109,  81,  87,
  1583.   95,  98, 103, 104, 103,  62,  77, 113,
  1584.  121, 112, 100, 120,  92, 101, 103,  99
  1585. };
  1586.  
  1587. char std_chrominance_quant_tbl[64] = {
  1588.   17,  18,  18,  24,  21,  24,  47,  26,
  1589.   26,  47,  99,  66,  56,  66,  99,  99,
  1590.   99,  99,  99,  99,  99,  99,  99,  99,
  1591.   99,  99,  99,  99,  99,  99,  99,  99,
  1592.   99,  99,  99,  99,  99,  99,  99,  99,
  1593.   99,  99,  99,  99,  99,  99,  99,  99,
  1594.   99,  99,  99,  99,  99,  99,  99,  99,
  1595.   99,  99,  99,  99,  99,  99,  99,  99
  1596. };
  1597.  
  1598. #define JPG_HANDLE_RST(rst_int,rst_cnt) {                                       \
  1599.   if ( ((rst_int) && (rst_cnt==0)) /* || (jpg_marker)*/ ) {                     \
  1600.     jpg_h_bbuf = 0;                                                             \
  1601.     jpg_h_bnum = 0;                                                             \
  1602.     /* DEBUG_LEVEL1 kprintf("  jRST_INT %d rst_cnt %d\n", rst_int,rst_cnt); */  \
  1603.     if (jpg_marker) {                                                           \
  1604.       /* DEBUG_LEVEL1 kprintf("  jpg_marker(%x)\n",jpg_marker); */              \
  1605.       if (jpg_marker == M_EOI) {                                                \
  1606.         jpg_saw_EOI = xaTRUE;                                                   \
  1607.         return(xaTRUE);                                                         \
  1608.       } else                                                                    \
  1609.         if ( !((jpg_marker >= M_RST0) && (jpg_marker <= M_RST7))) {             \
  1610.           /* kprintf("JPEG: unexp marker(%x)\n",jpg_marker); */                 \
  1611.           return(xaFALSE);                                                      \
  1612.         }                                                                       \
  1613.       jpg_marker = 0;                                                           \
  1614.     } else                                                                      \
  1615.       if (jpg_read_RST_marker()==xaFALSE) {                                     \
  1616.         /* kprintf("RST marker false\n"); */                                    \
  1617.         return(xaFALSE);                                                        \
  1618.       }                                                                         \
  1619.       jpg_comps[0].dc = jpg_comps[1].dc = jpg_comps[2].dc = 0;                  \
  1620.       rst_cnt = rst_int;                                                        \
  1621.   } else                                                                        \
  1622.     rst_cnt--;                                                                  \
  1623. };
  1624.  
  1625. #define JPG_TST_MARKER(rst_int,rst_cnt) {                          \
  1626.   if (jpg_marker) {                                                \
  1627.     /* DEBUG_LEVEL1 kprintf("  jpg_marker(%x)\n",jpg_marker); */   \
  1628.     if (jpg_marker == M_EOI) {                                     \
  1629.       jpg_saw_EOI = xaTRUE;                                        \
  1630.       /* return(xaTRUE); */                                        \
  1631.      } else                                                        \
  1632.        if ( !((jpg_marker >= M_RST0) && (jpg_marker <= M_RST7))) { \
  1633.          /* kprintf("JPEG: unexp marker(%x)\n",jpg_marker); */     \
  1634.          return(xaFALSE);                                          \
  1635.        } else {                                                    \
  1636.          jpg_comps[0].dc = jpg_comps[1].dc = jpg_comps[2].dc = 0;  \
  1637.          rst_cnt = rst_int;                                        \
  1638.          jpg_marker = 0;                                           \
  1639.          jpg_h_bbuf = 0;                                           \
  1640.          jpg_h_bnum = 0;                                           \
  1641.        }                                                           \
  1642.   }                                                                \
  1643. };
  1644. /* \\\ */
  1645.  
  1646. /* /// "jpg_decode_111111()" */
  1647. ulong jpg_decode_111111(uchar *image, ulong width, ulong height, ulong interleave, ulong row_offset, ulong imagex, ulong imagey, ulong xgray)
  1648. {
  1649.   uchar *iptr = image;
  1650.   ulong x,mcu_cols,mcu_rows;
  1651.   ulong *qtab0,*qtab1,*qtab2;
  1652.   uchar *Ybuf,*Ubuf,*Vbuf;
  1653.   ulong rst_count;
  1654.   ulong orow_size = imagex*bytes_pixel;
  1655.  
  1656.   if (row_offset) iptr += row_offset * orow_size;
  1657.   orow_size *= interleave;
  1658.   if (interleave == 2) imagey >>= 1;
  1659.  
  1660.   qtab0 = jpg_quant_tables[ jpg_comps[0].qtbl_num ];
  1661.   qtab1 = jpg_quant_tables[ jpg_comps[1].qtbl_num ];
  1662.   qtab2 = jpg_quant_tables[ jpg_comps[2].qtbl_num ];
  1663.  
  1664.   mcu_cols = (width  + 7) / 8;
  1665.   mcu_rows = (height + 7) / 8;
  1666.   // DEBUG_LEVEL1 kprintf("111111 begin MCUS(%d,%d)\n",mcu_cols,mcu_rows);
  1667.   jpg_marker = 0x00;
  1668.  
  1669.   rst_count = jpg_rst_interval;
  1670.   while(mcu_rows--)
  1671.   { 
  1672.     Ybuf = yuvBuf->yBuf; Ubuf = yuvBuf->uBuf; Vbuf = yuvBuf->vBuf;
  1673.     x = mcu_cols;
  1674.     while(x--)
  1675.     { 
  1676.       // DEBUG_LEVEL1 kprintf("  MCU XY(%d,%d)\n",x,mcu_rows);
  1677.       JPG_HANDLE_RST(jpg_rst_interval,rst_count);
  1678.  
  1679.       jpg_huffparse(&jpg_comps[0],jpg_dct_buf,qtab0,Ybuf); Ybuf += DCTSIZE2;
  1680.       if (gray==0)
  1681.       {
  1682.         jpg_huffparse(&jpg_comps[1],jpg_dct_buf,qtab1,Ubuf); Ubuf += DCTSIZE2;
  1683.         jpg_huffparse(&jpg_comps[2],jpg_dct_buf,qtab2,Vbuf); Vbuf += DCTSIZE2;
  1684.       } 
  1685.       JPG_TST_MARKER(jpg_rst_interval,rst_count);
  1686.     } /* end of mcu_cols */
  1687.  
  1688.     // DEBUG_LEVEL1 kprintf("imagey %d\n",imagey);
  1689.     // (void)(color_func)(iptr,imagex,xaMIN(imagey,8),(mcu_cols * DCTSIZE2), orow_size, &jpg_YUVBufs,&def_yuv_tabs, map_flag,map,chdr);
  1690.     if (xgray) MCU111111toGray(iptr,imagex,xaMIN(imagey,8),(mcu_cols * DCTSIZE2), orow_size);
  1691.     else       mcu111111(iptr,imagex,xaMIN(imagey,8),(mcu_cols * DCTSIZE2), orow_size);
  1692.     imagey -= 8;  iptr += (orow_size << 3);
  1693.  
  1694.   } /* end of mcu_rows */
  1695.   if (jpg_marker) { jpg_h_bbuf = 0; jpg_h_bnum = 0; }
  1696.   return(xaTRUE);
  1697. }
  1698. /* \\\ */
  1699.  
  1700. /* /// "jpg_decode_211111()" */
  1701. ulong jpg_decode_211111(uchar *image, ulong width, ulong height, ulong interleave, ulong row_offset, ulong imagex, ulong imagey)
  1702. {
  1703.   uchar *iptr = image;
  1704.   ulong x,mcu_cols,mcu_rows;
  1705.   ulong *qtab0,*qtab1,*qtab2;
  1706.   uchar *Ybuf,*Ubuf,*Vbuf;
  1707.   ulong rst_count;
  1708.   ulong orow_size = imagex*bytes_pixel;
  1709.  
  1710.   if (row_offset) iptr += row_offset * orow_size;
  1711.   orow_size *= interleave;
  1712.   if (interleave == 2) imagey >>= 1;
  1713.   imagex++; imagex >>= 1;
  1714.  
  1715.   qtab0 = jpg_quant_tables[ jpg_comps[0].qtbl_num ];
  1716.   qtab1 = jpg_quant_tables[ jpg_comps[1].qtbl_num ];
  1717.   qtab2 = jpg_quant_tables[ jpg_comps[2].qtbl_num ];
  1718.  
  1719.   mcu_cols = (width  + 15) / 16;
  1720.   mcu_rows = (height +  7) / 8;
  1721.   // DEBUG_LEVEL1 kprintf("211111 begin MCUS(%d,%d)\n",mcu_cols,mcu_rows);
  1722.   jpg_marker = 0x00;
  1723.  
  1724.   rst_count = jpg_rst_interval;
  1725.   while(mcu_rows--)
  1726.   { 
  1727.     Ybuf = yuvBuf->yBuf; Ubuf = yuvBuf->uBuf; Vbuf = yuvBuf->vBuf;
  1728.     x = mcu_cols;
  1729.     while(x--)
  1730.     { /* DEBUG_LEVEL1 kprintf("MCU XY(%d,%d)\n", x,mcu_rows); */
  1731.  
  1732.       JPG_HANDLE_RST(jpg_rst_interval,rst_count);
  1733.  
  1734.       jpg_huffparse(&jpg_comps[0],jpg_dct_buf,qtab0,Ybuf); Ybuf += DCTSIZE2;
  1735.       jpg_huffparse(&jpg_comps[0],jpg_dct_buf,qtab0,Ybuf); Ybuf += DCTSIZE2;
  1736.       jpg_huffparse(&jpg_comps[1],jpg_dct_buf,qtab1,Ubuf); Ubuf += DCTSIZE2;
  1737.       jpg_huffparse(&jpg_comps[2],jpg_dct_buf,qtab2,Vbuf); Vbuf += DCTSIZE2;
  1738.       JPG_TST_MARKER(jpg_rst_interval,rst_count);
  1739.     } /* end of mcu_cols */
  1740.  
  1741.     // (void)(color_func)(iptr,imagex,xaMIN(imagey,8),(mcu_cols * DCTSIZE2), orow_size, &jpg_YUVBufs,&def_yuv_tabs, map_flag,map,chdr);
  1742.     mcu211111(iptr,imagex,xaMIN(imagey,8),(mcu_cols * DCTSIZE2), orow_size);
  1743.     imagey -= 8;  iptr += (orow_size << 3);
  1744.  
  1745.   } /* end of mcu_rows */
  1746.   if (jpg_marker) { jpg_h_bbuf = 0; jpg_h_bnum = 0; }
  1747.   return(xaTRUE);
  1748. }
  1749. /* \\\ */
  1750.  
  1751. /* /// "jpg_decode_221111()" */
  1752. ulong jpg_decode_221111(uchar *image, ulong width, ulong height, ulong interleave, ulong row_offset, ulong imagex, ulong imagey)
  1753. { uchar *iptr = image;
  1754.   long x,mcu_cols,mcu_rows;
  1755.   ulong *qtab0,*qtab1,*qtab2;
  1756.   uchar *Ybuf,*Ubuf,*Vbuf;
  1757.   ulong rst_count;
  1758.   ulong orow_size = imagex*bytes_pixel;
  1759.  
  1760.   if (row_offset) iptr += row_offset * orow_size;
  1761.   orow_size *= interleave;
  1762.   if (interleave == 2) imagey >>= 1;
  1763.   imagex++; imagex >>= 1;  /* 2h */
  1764.   qtab0 = jpg_quant_tables[ jpg_comps[0].qtbl_num ];
  1765.   qtab1 = jpg_quant_tables[ jpg_comps[1].qtbl_num ];
  1766.   qtab2 = jpg_quant_tables[ jpg_comps[2].qtbl_num ];
  1767.  
  1768.   mcu_cols = (width  + 15) / 16;
  1769.   mcu_rows = (height + 15) / 16;
  1770.   // DEBUG_LEVEL1 kprintf("221111 begin MCUS(%d,%d)\n",mcu_cols,mcu_rows);
  1771.   jpg_marker = 0x00;
  1772.  
  1773.   rst_count = jpg_rst_interval;
  1774.   while(mcu_rows--)
  1775.   { Ybuf = yuvBuf->yBuf; Ubuf = yuvBuf->uBuf; Vbuf = yuvBuf->vBuf;
  1776.     x = mcu_cols; while(x--)
  1777.     { // DEBUG_LEVEL1 kprintf("  MCU XY(%d,%d)\n",x,mcu_rows);
  1778.  
  1779.       JPG_HANDLE_RST(jpg_rst_interval,rst_count);
  1780.  
  1781.         /* Y0 Y1 Y2 Y3 U V */
  1782.       jpg_huffparse(&jpg_comps[0],jpg_dct_buf,qtab0,Ybuf); Ybuf += DCTSIZE2;
  1783.       jpg_huffparse(&jpg_comps[0],jpg_dct_buf,qtab0,Ybuf); Ybuf += DCTSIZE2;
  1784.       jpg_huffparse(&jpg_comps[0],jpg_dct_buf,qtab0,Ybuf); Ybuf += DCTSIZE2;
  1785.       jpg_huffparse(&jpg_comps[0],jpg_dct_buf,qtab0,Ybuf); Ybuf += DCTSIZE2;
  1786.       jpg_huffparse(&jpg_comps[1],jpg_dct_buf,qtab1,Ubuf); Ubuf += DCTSIZE2;
  1787.       jpg_huffparse(&jpg_comps[2],jpg_dct_buf,qtab2,Vbuf); Vbuf += DCTSIZE2;
  1788.       JPG_TST_MARKER(jpg_rst_interval,rst_count);
  1789.     } /* end of mcu_cols */
  1790.  
  1791.     // (void)(color_func)(iptr,imagex,xaMIN(imagey,16),(mcu_cols * DCTSIZE2),orow_size,&jpg_YUVBufs,&def_yuv_tabs,map_flag,map,chdr);
  1792.     mcu221111(iptr,imagex,xaMIN(imagey,16),(mcu_cols * DCTSIZE2), orow_size);
  1793.     imagey -= 16;  iptr += (orow_size << 4);
  1794.  
  1795.   } /* end of mcu_rows */
  1796.   if (jpg_marker) { jpg_h_bbuf = 0; jpg_h_bnum = 0; }
  1797.   // DEBUG_LEVEL1 kprintf("411: done\n");
  1798.   return(xaTRUE);
  1799. }
  1800. /* \\\ */
  1801.  
  1802. /* /// "jpg_decode_411111()" */
  1803. ulong jpg_decode_411111(uchar *image, ulong width, ulong height, ulong interleave, ulong row_offset, ulong imagex, ulong imagey)
  1804. { uchar *iptr = image;
  1805.   long x,mcu_cols,mcu_rows;
  1806.   ulong *qtab0,*qtab1,*qtab2;
  1807.   uchar *Ybuf,*Ubuf,*Vbuf;
  1808.   ulong rst_count;
  1809.   ulong orow_size = imagex*bytes_pixel;
  1810.  
  1811.   if (row_offset) iptr += row_offset * orow_size;
  1812.   orow_size *= interleave;
  1813.   if (interleave == 2) imagey >>= 1;
  1814.   imagex +=3; imagex >>= 2; /* 4h */
  1815.   qtab0 = jpg_quant_tables[ jpg_comps[0].qtbl_num ];
  1816.   qtab1 = jpg_quant_tables[ jpg_comps[1].qtbl_num ];
  1817.   qtab2 = jpg_quant_tables[ jpg_comps[2].qtbl_num ];
  1818.  
  1819.   mcu_cols = (width  + 31) / 32;
  1820.   mcu_rows = (height + 7) / 8;
  1821.   // DEBUG_LEVEL1 kprintf("411111 begin MCUS(%d,%d)\n",mcu_cols,mcu_rows);
  1822.   jpg_marker = 0x00;
  1823.  
  1824.   rst_count = jpg_rst_interval;
  1825.   while(mcu_rows--)
  1826.   { Ybuf = yuvBuf->yBuf; Ubuf = yuvBuf->uBuf; Vbuf = yuvBuf->vBuf;
  1827.     x = mcu_cols; while(x--)
  1828.     { // DEBUG_LEVEL1 kprintf("  MCU XY(%d,%d)\n",x,mcu_rows);
  1829.  
  1830.       JPG_HANDLE_RST(jpg_rst_interval,rst_count);
  1831.  
  1832.         /* Y0 Y1 Y2 Y3 U V */
  1833.       jpg_huffparse(&jpg_comps[0],jpg_dct_buf,qtab0,Ybuf); Ybuf += DCTSIZE2;
  1834.       jpg_huffparse(&jpg_comps[0],jpg_dct_buf,qtab0,Ybuf); Ybuf += DCTSIZE2;
  1835.       jpg_huffparse(&jpg_comps[0],jpg_dct_buf,qtab0,Ybuf); Ybuf += DCTSIZE2;
  1836.       jpg_huffparse(&jpg_comps[0],jpg_dct_buf,qtab0,Ybuf); Ybuf += DCTSIZE2;
  1837.       jpg_huffparse(&jpg_comps[1],jpg_dct_buf,qtab1,Ubuf); Ubuf += DCTSIZE2;
  1838.       jpg_huffparse(&jpg_comps[2],jpg_dct_buf,qtab2,Vbuf); Vbuf += DCTSIZE2;
  1839.       JPG_TST_MARKER(jpg_rst_interval,rst_count);
  1840.     } /* end of mcu_cols */
  1841.  
  1842.     // (void)(color_func)(iptr,imagex,xaMIN(imagey,8),(mcu_cols * DCTSIZE2),orow_size,&jpg_YUVBufs,&def_yuv_tabs,map_flag,map,chdr);
  1843.     mcu411111(iptr,imagex,xaMIN(imagey,8),(mcu_cols * DCTSIZE2), orow_size);
  1844.     imagey -= 8;  iptr += (orow_size << 3);
  1845.  
  1846.   } /* end of mcu_rows */
  1847.   if (jpg_marker) { jpg_h_bbuf = 0; jpg_h_bnum = 0; }
  1848.   // DEBUG_LEVEL1 kprintf("411: done\n");
  1849.   return(xaTRUE);
  1850. }
  1851. /* \\\ */
  1852.  
  1853. /* /// "j_rev_dct()" */
  1854. #ifdef RIGHT_SHIFT_IS_UNSIGNED
  1855. #define SHIFT_TEMPS     long shift_temp;
  1856. #define RIGHT_SHIFT(x,shft)  \
  1857.         ((shift_temp = (x)) < 0 ? \
  1858.          (shift_temp >> (shft)) | ((~((long) 0)) << (32-(shft))) : \
  1859.          (shift_temp >> (shft)))
  1860. #else
  1861. #define SHIFT_TEMPS
  1862. #define RIGHT_SHIFT(x,shft)     ((x) >> (shft))
  1863. #endif
  1864.  
  1865. #define PASS1_BITS  2
  1866.  
  1867. #define ONE     ((long) 1)
  1868.  
  1869. #define CONST_BITS 13
  1870.  
  1871. #define CONST_SCALE (ONE << CONST_BITS)
  1872.  
  1873. #define FIX(x)  ((long) ((x) * CONST_SCALE + 0.5))
  1874.  
  1875. #define DESCALE(x,n)  RIGHT_SHIFT((x) + (ONE << ((n)-1)), n)
  1876.  
  1877. #define MULTIPLY(var,const)  ((var) * (const))
  1878.  
  1879. void j_rev_dct (short *data, uchar *outptr, uchar *limit)
  1880. {
  1881.   long tmp0, tmp1, tmp2, tmp3;
  1882.   long tmp10, tmp11, tmp12, tmp13;
  1883.   long z1, z2, z3, z4, z5;
  1884.   long d0, d1, d2, d3, d4, d5, d6, d7;
  1885.   register short *dataptr;
  1886.   int rowctr;
  1887.   SHIFT_TEMPS
  1888.  
  1889.   /* Pass 1: process rows. */
  1890.   /* Note results are scaled up by sqrt(8) compared to a true IDCT; */
  1891.   /* furthermore, we scale the results by 2**PASS1_BITS. */
  1892.  
  1893.   dataptr = data;
  1894.  
  1895.   for (rowctr = DCTSIZE-1; rowctr >= 0; rowctr--)
  1896.   {
  1897.     /* Due to quantization, we will usually find that many of the input
  1898.      * coefficients are zero, especially the AC terms.  We can exploit this
  1899.      * by short-circuiting the IDCT calculation for any row in which all
  1900.      * the AC terms are zero.  In that case each output is equal to the
  1901.      * DC coefficient (with scale factor as needed).
  1902.      * With typical images and quantization tables, half or more of the
  1903.      * row DCT calculations can be simplified this way.
  1904.      */
  1905.  
  1906.     register int *idataptr = (int*)dataptr;
  1907.     d0 = dataptr[0];
  1908.     d1 = dataptr[1];
  1909.     if ((d1 == 0) && (idataptr[1] | idataptr[2] | idataptr[3]) == 0) {
  1910.       /* AC terms all zero */
  1911.       if (d0) {
  1912.           /* Compute a 32 bit value to assign. */
  1913.           short dcval = (short) (d0 << PASS1_BITS);
  1914.           register int v = (dcval & 0xffff) | ((dcval << 16) & 0xffff0000);
  1915.  
  1916.           idataptr[0] = v;
  1917.           idataptr[1] = v;
  1918.           idataptr[2] = v;
  1919.           idataptr[3] = v;
  1920.       }
  1921.  
  1922.       dataptr += DCTSIZE;       /* advance pointer to next row */
  1923.       continue;
  1924.     }
  1925.     d2 = dataptr[2];
  1926.     d3 = dataptr[3];
  1927.     d4 = dataptr[4];
  1928.     d5 = dataptr[5];
  1929.     d6 = dataptr[6];
  1930.     d7 = dataptr[7];
  1931.  
  1932.     /* Even part: reverse the even part of the forward DCT. */
  1933.     /* The rotator is sqrt(2)*c(-6). */
  1934.     if (d6) {
  1935.         if (d4) {
  1936.             if (d2) {
  1937.                 if (d0) {
  1938.                     /* d0 != 0, d2 != 0, d4 != 0, d6 != 0 */
  1939.                     z1 = MULTIPLY(d2 + d6, FIX(0.541196100));
  1940.                     tmp2 = z1 + MULTIPLY(d6, - FIX(1.847759065));
  1941.                     tmp3 = z1 + MULTIPLY(d2, FIX(0.765366865));
  1942.  
  1943.                     tmp0 = (d0 + d4) << CONST_BITS;
  1944.                     tmp1 = (d0 - d4) << CONST_BITS;
  1945.  
  1946.                     tmp10 = tmp0 + tmp3;
  1947.                     tmp13 = tmp0 - tmp3;
  1948.                     tmp11 = tmp1 + tmp2;
  1949.                     tmp12 = tmp1 - tmp2;
  1950.                 } else {
  1951.                     /* d0 == 0, d2 != 0, d4 != 0, d6 != 0 */
  1952.                     z1 = MULTIPLY(d2 + d6, FIX(0.541196100));
  1953.                     tmp2 = z1 + MULTIPLY(d6, - FIX(1.847759065));
  1954.                     tmp3 = z1 + MULTIPLY(d2, FIX(0.765366865));
  1955.  
  1956.                     tmp0 = d4 << CONST_BITS;
  1957.  
  1958.                     tmp10 = tmp0 + tmp3;
  1959.                     tmp13 = tmp0 - tmp3;
  1960.                     tmp11 = tmp2 - tmp0;
  1961.                     tmp12 = -(tmp0 + tmp2);
  1962.                 }
  1963.             } else {
  1964.                 if (d0) {
  1965.                     /* d0 != 0, d2 == 0, d4 != 0, d6 != 0 */
  1966.                     tmp2 = MULTIPLY(d6, - FIX(1.306562965));
  1967.                     tmp3 = MULTIPLY(d6, FIX(0.541196100));
  1968.  
  1969.                     tmp0 = (d0 + d4) << CONST_BITS;
  1970.                     tmp1 = (d0 - d4) << CONST_BITS;
  1971.  
  1972.                     tmp10 = tmp0 + tmp3;
  1973.                     tmp13 = tmp0 - tmp3;
  1974.                     tmp11 = tmp1 + tmp2;
  1975.                     tmp12 = tmp1 - tmp2;
  1976.                 } else {
  1977.                     /* d0 == 0, d2 == 0, d4 != 0, d6 != 0 */
  1978.                     tmp2 = MULTIPLY(d6, -FIX(1.306562965));
  1979.                     tmp3 = MULTIPLY(d6, FIX(0.541196100));
  1980.  
  1981.                     tmp0 = d4 << CONST_BITS;
  1982.  
  1983.                     tmp10 = tmp0 + tmp3;
  1984.                     tmp13 = tmp0 - tmp3;
  1985.                     tmp11 = tmp2 - tmp0;
  1986.                     tmp12 = -(tmp0 + tmp2);
  1987.                 }
  1988.             }
  1989.         } else {
  1990.             if (d2) {
  1991.                 if (d0) {
  1992.                     /* d0 != 0, d2 != 0, d4 == 0, d6 != 0 */
  1993.                     z1 = MULTIPLY(d2 + d6, FIX(0.541196100));
  1994.                     tmp2 = z1 + MULTIPLY(d6, - FIX(1.847759065));
  1995.                     tmp3 = z1 + MULTIPLY(d2, FIX(0.765366865));
  1996.  
  1997.                     tmp0 = d0 << CONST_BITS;
  1998.  
  1999.                     tmp10 = tmp0 + tmp3;
  2000.                     tmp13 = tmp0 - tmp3;
  2001.                     tmp11 = tmp0 + tmp2;
  2002.                     tmp12 = tmp0 - tmp2;
  2003.                 } else {
  2004.                     /* d0 == 0, d2 != 0, d4 == 0, d6 != 0 */
  2005.                     z1 = MULTIPLY(d2 + d6, FIX(0.541196100));
  2006.                     tmp2 = z1 + MULTIPLY(d6, - FIX(1.847759065));
  2007.                     tmp3 = z1 + MULTIPLY(d2, FIX(0.765366865));
  2008.  
  2009.                     tmp10 = tmp3;
  2010.                     tmp13 = -tmp3;
  2011.                     tmp11 = tmp2;
  2012.                     tmp12 = -tmp2;
  2013.                 }
  2014.             } else {
  2015.                 if (d0) {
  2016.                     /* d0 != 0, d2 == 0, d4 == 0, d6 != 0 */
  2017.                     tmp2 = MULTIPLY(d6, - FIX(1.306562965));
  2018.                     tmp3 = MULTIPLY(d6, FIX(0.541196100));
  2019.  
  2020.                     tmp0 = d0 << CONST_BITS;
  2021.  
  2022.                     tmp10 = tmp0 + tmp3;
  2023.                     tmp13 = tmp0 - tmp3;
  2024.                     tmp11 = tmp0 + tmp2;
  2025.                     tmp12 = tmp0 - tmp2;
  2026.                 } else {
  2027.                     /* d0 == 0, d2 == 0, d4 == 0, d6 != 0 */
  2028.                     tmp2 = MULTIPLY(d6, - FIX(1.306562965));
  2029.                     tmp3 = MULTIPLY(d6, FIX(0.541196100));
  2030.  
  2031.                     tmp10 = tmp3;
  2032.                     tmp13 = -tmp3;
  2033.                     tmp11 = tmp2;
  2034.                     tmp12 = -tmp2;
  2035.                 }
  2036.             }
  2037.         }
  2038.     } else {
  2039.         if (d4) {
  2040.             if (d2) {
  2041.                 if (d0) {
  2042.                     /* d0 != 0, d2 != 0, d4 != 0, d6 == 0 */
  2043.                     tmp2 = MULTIPLY(d2, FIX(0.541196100));
  2044.                     tmp3 = MULTIPLY(d2, FIX(1.306562965));
  2045.  
  2046.                     tmp0 = (d0 + d4) << CONST_BITS;
  2047.                     tmp1 = (d0 - d4) << CONST_BITS;
  2048.  
  2049.                     tmp10 = tmp0 + tmp3;
  2050.                     tmp13 = tmp0 - tmp3;
  2051.                     tmp11 = tmp1 + tmp2;
  2052.                     tmp12 = tmp1 - tmp2;
  2053.                 } else {
  2054.                     /* d0 == 0, d2 != 0, d4 != 0, d6 == 0 */
  2055.                     tmp2 = MULTIPLY(d2, FIX(0.541196100));
  2056.                     tmp3 = MULTIPLY(d2, FIX(1.306562965));
  2057.  
  2058.                     tmp0 = d4 << CONST_BITS;
  2059.  
  2060.                     tmp10 = tmp0 + tmp3;
  2061.                     tmp13 = tmp0 - tmp3;
  2062.                     tmp11 = tmp2 - tmp0;
  2063.                     tmp12 = -(tmp0 + tmp2);
  2064.                 }
  2065.             } else {
  2066.                 if (d0) {
  2067.                     /* d0 != 0, d2 == 0, d4 != 0, d6 == 0 */
  2068.                     tmp10 = tmp13 = (d0 + d4) << CONST_BITS;
  2069.                     tmp11 = tmp12 = (d0 - d4) << CONST_BITS;
  2070.                 } else {
  2071.                     /* d0 == 0, d2 == 0, d4 != 0, d6 == 0 */
  2072.                     tmp10 = tmp13 = d4 << CONST_BITS;
  2073.                     tmp11 = tmp12 = -tmp10;
  2074.                 }
  2075.             }
  2076.         } else {
  2077.             if (d2) {
  2078.                 if (d0) {
  2079.                     /* d0 != 0, d2 != 0, d4 == 0, d6 == 0 */
  2080.                     tmp2 = MULTIPLY(d2, FIX(0.541196100));
  2081.                     tmp3 = MULTIPLY(d2, FIX(1.306562965));
  2082.  
  2083.                     tmp0 = d0 << CONST_BITS;
  2084.  
  2085.                     tmp10 = tmp0 + tmp3;
  2086.                     tmp13 = tmp0 - tmp3;
  2087.                     tmp11 = tmp0 + tmp2;
  2088.                     tmp12 = tmp0 - tmp2;
  2089.                 } else {
  2090.                     /* d0 == 0, d2 != 0, d4 == 0, d6 == 0 */
  2091.                     tmp2 = MULTIPLY(d2, FIX(0.541196100));
  2092.                     tmp3 = MULTIPLY(d2, FIX(1.306562965));
  2093.  
  2094.                     tmp10 = tmp3;
  2095.                     tmp13 = -tmp3;
  2096.                     tmp11 = tmp2;
  2097.                     tmp12 = -tmp2;
  2098.                 }
  2099.             } else {
  2100.                 if (d0) {
  2101.                     /* d0 != 0, d2 == 0, d4 == 0, d6 == 0 */
  2102.                     tmp10 = tmp13 = tmp11 = tmp12 = d0 << CONST_BITS;
  2103.                 } else {
  2104.                     /* d0 == 0, d2 == 0, d4 == 0, d6 == 0 */
  2105.                     tmp10 = tmp13 = tmp11 = tmp12 = 0;
  2106.                 }
  2107.             }
  2108.         }
  2109.     }
  2110.  
  2111.  
  2112.     /* Odd part per figure 8; the matrix is unitary and hence its
  2113.      * transpose is its inverse.  i0..i3 are y7,y5,y3,y1 respectively.
  2114.      */
  2115.  
  2116.     if (d7) {
  2117.         if (d5) {
  2118.             if (d3) {
  2119.                 if (d1) {
  2120.                     /* d1 != 0, d3 != 0, d5 != 0, d7 != 0 */
  2121.                     z1 = d7 + d1;
  2122.                     z2 = d5 + d3;
  2123.                     z3 = d7 + d3;
  2124.                     z4 = d5 + d1;
  2125.                     z5 = MULTIPLY(z3 + z4, FIX(1.175875602));
  2126.  
  2127.                     tmp0 = MULTIPLY(d7, FIX(0.298631336));
  2128.                     tmp1 = MULTIPLY(d5, FIX(2.053119869));
  2129.                     tmp2 = MULTIPLY(d3, FIX(3.072711026));
  2130.                     tmp3 = MULTIPLY(d1, FIX(1.501321110));
  2131.                     z1 = MULTIPLY(z1, - FIX(0.899976223));
  2132.                     z2 = MULTIPLY(z2, - FIX(2.562915447));
  2133.                     z3 = MULTIPLY(z3, - FIX(1.961570560));
  2134.                     z4 = MULTIPLY(z4, - FIX(0.390180644));
  2135.  
  2136.                     z3 += z5;
  2137.                     z4 += z5;
  2138.  
  2139.                     tmp0 += z1 + z3;
  2140.                     tmp1 += z2 + z4;
  2141.                     tmp2 += z2 + z3;
  2142.                     tmp3 += z1 + z4;
  2143.                 } else {
  2144.                     /* d1 == 0, d3 != 0, d5 != 0, d7 != 0 */
  2145.                     z1 = d7;
  2146.                     z2 = d5 + d3;
  2147.                     z3 = d7 + d3;
  2148.                     z5 = MULTIPLY(z3 + d5, FIX(1.175875602));
  2149.  
  2150.                     tmp0 = MULTIPLY(d7, FIX(0.298631336));
  2151.                     tmp1 = MULTIPLY(d5, FIX(2.053119869));
  2152.                     tmp2 = MULTIPLY(d3, FIX(3.072711026));
  2153.                     z1 = MULTIPLY(d7, - FIX(0.899976223));
  2154.                     z2 = MULTIPLY(z2, - FIX(2.562915447));
  2155.                     z3 = MULTIPLY(z3, - FIX(1.961570560));
  2156.                     z4 = MULTIPLY(d5, - FIX(0.390180644));
  2157.  
  2158.                     z3 += z5;
  2159.                     z4 += z5;
  2160.  
  2161.                     tmp0 += z1 + z3;
  2162.                     tmp1 += z2 + z4;
  2163.                     tmp2 += z2 + z3;
  2164.                     tmp3 = z1 + z4;
  2165.                 }
  2166.             } else {
  2167.                 if (d1) {
  2168.                     /* d1 != 0, d3 == 0, d5 != 0, d7 != 0 */
  2169.                     z1 = d7 + d1;
  2170.                     z2 = d5;
  2171.                     z3 = d7;
  2172.                     z4 = d5 + d1;
  2173.                     z5 = MULTIPLY(z3 + z4, FIX(1.175875602));
  2174.  
  2175.                     tmp0 = MULTIPLY(d7, FIX(0.298631336));
  2176.                     tmp1 = MULTIPLY(d5, FIX(2.053119869));
  2177.                     tmp3 = MULTIPLY(d1, FIX(1.501321110));
  2178.                     z1 = MULTIPLY(z1, - FIX(0.899976223));
  2179.                     z2 = MULTIPLY(d5, - FIX(2.562915447));
  2180.                     z3 = MULTIPLY(d7, - FIX(1.961570560));
  2181.                     z4 = MULTIPLY(z4, - FIX(0.390180644));
  2182.  
  2183.                     z3 += z5;
  2184.                     z4 += z5;
  2185.  
  2186.                     tmp0 += z1 + z3;
  2187.                     tmp1 += z2 + z4;
  2188.                     tmp2 = z2 + z3;
  2189.                     tmp3 += z1 + z4;
  2190.                 } else {
  2191.                     /* d1 == 0, d3 == 0, d5 != 0, d7 != 0 */
  2192.                     tmp0 = MULTIPLY(d7, - FIX(0.601344887));
  2193.                     z1 = MULTIPLY(d7, - FIX(0.899976223));
  2194.                     z3 = MULTIPLY(d7, - FIX(1.961570560));
  2195.                     tmp1 = MULTIPLY(d5, - FIX(0.509795578));
  2196.                     z2 = MULTIPLY(d5, - FIX(2.562915447));
  2197.                     z4 = MULTIPLY(d5, - FIX(0.390180644));
  2198.                     z5 = MULTIPLY(d5 + d7, FIX(1.175875602));
  2199.  
  2200.                     z3 += z5;
  2201.                     z4 += z5;
  2202.  
  2203.                     tmp0 += z3;
  2204.                     tmp1 += z4;
  2205.                     tmp2 = z2 + z3;
  2206.                     tmp3 = z1 + z4;
  2207.                 }
  2208.             }
  2209.         } else {
  2210.             if (d3) {
  2211.                 if (d1) {
  2212.                     /* d1 != 0, d3 != 0, d5 == 0, d7 != 0 */
  2213.                     z1 = d7 + d1;
  2214.                     z3 = d7 + d3;
  2215.                     z5 = MULTIPLY(z3 + d1, FIX(1.175875602));
  2216.  
  2217.                     tmp0 = MULTIPLY(d7, FIX(0.298631336));
  2218.                     tmp2 = MULTIPLY(d3, FIX(3.072711026));
  2219.                     tmp3 = MULTIPLY(d1, FIX(1.501321110));
  2220.                     z1 = MULTIPLY(z1, - FIX(0.899976223));
  2221.                     z2 = MULTIPLY(d3, - FIX(2.562915447));
  2222.                     z3 = MULTIPLY(z3, - FIX(1.961570560));
  2223.                     z4 = MULTIPLY(d1, - FIX(0.390180644));
  2224.  
  2225.                     z3 += z5;
  2226.                     z4 += z5;
  2227.  
  2228.                     tmp0 += z1 + z3;
  2229.                     tmp1 = z2 + z4;
  2230.                     tmp2 += z2 + z3;
  2231.                     tmp3 += z1 + z4;
  2232.                 } else {
  2233.                     /* d1 == 0, d3 != 0, d5 == 0, d7 != 0 */
  2234.                     z3 = d7 + d3;
  2235.  
  2236.                     tmp0 = MULTIPLY(d7, - FIX(0.601344887));
  2237.                     z1 = MULTIPLY(d7, - FIX(0.899976223));
  2238.                     tmp2 = MULTIPLY(d3, FIX(0.509795579));
  2239.                     z2 = MULTIPLY(d3, - FIX(2.562915447));
  2240.                     z5 = MULTIPLY(z3, FIX(1.175875602));
  2241.                     z3 = MULTIPLY(z3, - FIX(0.785694958));
  2242.  
  2243.                     tmp0 += z3;
  2244.                     tmp1 = z2 + z5;
  2245.                     tmp2 += z3;
  2246.                     tmp3 = z1 + z5;
  2247.                 }
  2248.             } else {
  2249.                 if (d1) {
  2250.                     /* d1 != 0, d3 == 0, d5 == 0, d7 != 0 */
  2251.                     z1 = d7 + d1;
  2252.                     z5 = MULTIPLY(z1, FIX(1.175875602));
  2253.  
  2254.                     z1 = MULTIPLY(z1, FIX(0.275899379));
  2255.                     z3 = MULTIPLY(d7, - FIX(1.961570560));
  2256.                     tmp0 = MULTIPLY(d7, - FIX(1.662939224));
  2257.                     z4 = MULTIPLY(d1, - FIX(0.390180644));
  2258.                     tmp3 = MULTIPLY(d1, FIX(1.111140466));
  2259.  
  2260.                     tmp0 += z1;
  2261.                     tmp1 = z4 + z5;
  2262.                     tmp2 = z3 + z5;
  2263.                     tmp3 += z1;
  2264.                 } else {
  2265.                     /* d1 == 0, d3 == 0, d5 == 0, d7 != 0 */
  2266.                     tmp0 = MULTIPLY(d7, - FIX(1.387039845));
  2267.                     tmp1 = MULTIPLY(d7, FIX(1.175875602));
  2268.                     tmp2 = MULTIPLY(d7, - FIX(0.785694958));
  2269.                     tmp3 = MULTIPLY(d7, FIX(0.275899379));
  2270.                 }
  2271.             }
  2272.         }
  2273.     } else {
  2274.         if (d5) {
  2275.             if (d3) {
  2276.                 if (d1) {
  2277.                     /* d1 != 0, d3 != 0, d5 != 0, d7 == 0 */
  2278.                     z2 = d5 + d3;
  2279.                     z4 = d5 + d1;
  2280.                     z5 = MULTIPLY(d3 + z4, FIX(1.175875602));
  2281.  
  2282.                     tmp1 = MULTIPLY(d5, FIX(2.053119869));
  2283.                     tmp2 = MULTIPLY(d3, FIX(3.072711026));
  2284.                     tmp3 = MULTIPLY(d1, FIX(1.501321110));
  2285.                     z1 = MULTIPLY(d1, - FIX(0.899976223));
  2286.                     z2 = MULTIPLY(z2, - FIX(2.562915447));
  2287.                     z3 = MULTIPLY(d3, - FIX(1.961570560));
  2288.                     z4 = MULTIPLY(z4, - FIX(0.390180644));
  2289.  
  2290.                     z3 += z5;
  2291.                     z4 += z5;
  2292.  
  2293.                     tmp0 = z1 + z3;
  2294.                     tmp1 += z2 + z4;
  2295.                     tmp2 += z2 + z3;
  2296.                     tmp3 += z1 + z4;
  2297.                 } else {
  2298.                     /* d1 == 0, d3 != 0, d5 != 0, d7 == 0 */
  2299.                     z2 = d5 + d3;
  2300.  
  2301.                     z5 = MULTIPLY(z2, FIX(1.175875602));
  2302.                     tmp1 = MULTIPLY(d5, FIX(1.662939225));
  2303.                     z4 = MULTIPLY(d5, - FIX(0.390180644));
  2304.                     z2 = MULTIPLY(z2, - FIX(1.387039845));
  2305.                     tmp2 = MULTIPLY(d3, FIX(1.111140466));
  2306.                     z3 = MULTIPLY(d3, - FIX(1.961570560));
  2307.  
  2308.                     tmp0 = z3 + z5;
  2309.                     tmp1 += z2;
  2310.                     tmp2 += z2;
  2311.                     tmp3 = z4 + z5;
  2312.                 }
  2313.             } else {
  2314.                 if (d1) {
  2315.                     /* d1 != 0, d3 == 0, d5 != 0, d7 == 0 */
  2316.                     z4 = d5 + d1;
  2317.  
  2318.                     z5 = MULTIPLY(z4, FIX(1.175875602));
  2319.                     z1 = MULTIPLY(d1, - FIX(0.899976223));
  2320.                     tmp3 = MULTIPLY(d1, FIX(0.601344887));
  2321.                     tmp1 = MULTIPLY(d5, - FIX(0.509795578));
  2322.                     z2 = MULTIPLY(d5, - FIX(2.562915447));
  2323.                     z4 = MULTIPLY(z4, FIX(0.785694958));
  2324.  
  2325.                     tmp0 = z1 + z5;
  2326.                     tmp1 += z4;
  2327.                     tmp2 = z2 + z5;
  2328.                     tmp3 += z4;
  2329.                 } else {
  2330.                     /* d1 == 0, d3 == 0, d5 != 0, d7 == 0 */
  2331.                     tmp0 = MULTIPLY(d5, FIX(1.175875602));
  2332.                     tmp1 = MULTIPLY(d5, FIX(0.275899380));
  2333.                     tmp2 = MULTIPLY(d5, - FIX(1.387039845));
  2334.                     tmp3 = MULTIPLY(d5, FIX(0.785694958));
  2335.                 }
  2336.             }
  2337.         } else {
  2338.             if (d3) {
  2339.                 if (d1) {
  2340.                     /* d1 != 0, d3 != 0, d5 == 0, d7 == 0 */
  2341.                     z5 = d1 + d3;
  2342.                     tmp3 = MULTIPLY(d1, FIX(0.211164243));
  2343.                     tmp2 = MULTIPLY(d3, - FIX(1.451774981));
  2344.                     z1 = MULTIPLY(d1, FIX(1.061594337));
  2345.                     z2 = MULTIPLY(d3, - FIX(2.172734803));
  2346.                     z4 = MULTIPLY(z5, FIX(0.785694958));
  2347.                     z5 = MULTIPLY(z5, FIX(1.175875602));
  2348.  
  2349.                     tmp0 = z1 - z4;
  2350.                     tmp1 = z2 + z4;
  2351.                     tmp2 += z5;
  2352.                     tmp3 += z5;
  2353.                 } else {
  2354.                     /* d1 == 0, d3 != 0, d5 == 0, d7 == 0 */
  2355.                     tmp0 = MULTIPLY(d3, - FIX(0.785694958));
  2356.                     tmp1 = MULTIPLY(d3, - FIX(1.387039845));
  2357.                     tmp2 = MULTIPLY(d3, - FIX(0.275899379));
  2358.                     tmp3 = MULTIPLY(d3, FIX(1.175875602));
  2359.                 }
  2360.             } else {
  2361.                 if (d1) {
  2362.                     /* d1 != 0, d3 == 0, d5 == 0, d7 == 0 */
  2363.                     tmp0 = MULTIPLY(d1, FIX(0.275899379));
  2364.                     tmp1 = MULTIPLY(d1, FIX(0.785694958));
  2365.                     tmp2 = MULTIPLY(d1, FIX(1.175875602));
  2366.                     tmp3 = MULTIPLY(d1, FIX(1.387039845));
  2367.                 } else {
  2368.                     /* d1 == 0, d3 == 0, d5 == 0, d7 == 0 */
  2369.                     tmp0 = tmp1 = tmp2 = tmp3 = 0;
  2370.                 }
  2371.             }
  2372.         }
  2373.     }
  2374.  
  2375.     /* Final output stage: inputs are tmp10..tmp13, tmp0..tmp3 */
  2376.  
  2377.     dataptr[0] = (short) DESCALE(tmp10 + tmp3, CONST_BITS-PASS1_BITS);
  2378.     dataptr[7] = (short) DESCALE(tmp10 - tmp3, CONST_BITS-PASS1_BITS);
  2379.     dataptr[1] = (short) DESCALE(tmp11 + tmp2, CONST_BITS-PASS1_BITS);
  2380.     dataptr[6] = (short) DESCALE(tmp11 - tmp2, CONST_BITS-PASS1_BITS);
  2381.     dataptr[2] = (short) DESCALE(tmp12 + tmp1, CONST_BITS-PASS1_BITS);
  2382.     dataptr[5] = (short) DESCALE(tmp12 - tmp1, CONST_BITS-PASS1_BITS);
  2383.     dataptr[3] = (short) DESCALE(tmp13 + tmp0, CONST_BITS-PASS1_BITS);
  2384.     dataptr[4] = (short) DESCALE(tmp13 - tmp0, CONST_BITS-PASS1_BITS);
  2385.  
  2386.     dataptr += DCTSIZE;         /* advance pointer to next row */
  2387.   }
  2388.  
  2389.   /* Pass 2: process columns. */
  2390.   /* Note that we must descale the results by a factor of 8 == 2**3, */
  2391.   /* and also undo the PASS1_BITS scaling. */
  2392.  
  2393.   dataptr = data;
  2394.   for (rowctr = DCTSIZE-1; rowctr >= 0; rowctr--)
  2395.   {
  2396.     /* Columns of zeroes can be exploited in the same way as we did with rows.
  2397.      * However, the row calculation has created many nonzero AC terms, so the
  2398.      * simplification applies less often (typically 5% to 10% of the time).
  2399.      * On machines with very fast multiplication, it's possible that the
  2400.      * test takes more time than it's worth.  In that case this section
  2401.      * may be commented out.
  2402.      */
  2403.  
  2404.     d0 = dataptr[DCTSIZE*0];
  2405.     d1 = dataptr[DCTSIZE*1];
  2406.     d2 = dataptr[DCTSIZE*2];
  2407.     d3 = dataptr[DCTSIZE*3];
  2408.     d4 = dataptr[DCTSIZE*4];
  2409.     d5 = dataptr[DCTSIZE*5];
  2410.     d6 = dataptr[DCTSIZE*6];
  2411.     d7 = dataptr[DCTSIZE*7];
  2412.  
  2413.     /* Even part: reverse the even part of the forward DCT. */
  2414.     /* The rotator is sqrt(2)*c(-6). */
  2415.     if (d6) {
  2416.         if (d4) {
  2417.             if (d2) {
  2418.                 if (d0) {
  2419.                     /* d0 != 0, d2 != 0, d4 != 0, d6 != 0 */
  2420.                     z1 = MULTIPLY(d2 + d6, FIX(0.541196100));
  2421.                     tmp2 = z1 + MULTIPLY(d6, - FIX(1.847759065));
  2422.                     tmp3 = z1 + MULTIPLY(d2, FIX(0.765366865));
  2423.  
  2424.                     tmp0 = (d0 + d4) << CONST_BITS;
  2425.                     tmp1 = (d0 - d4) << CONST_BITS;
  2426.  
  2427.                     tmp10 = tmp0 + tmp3;
  2428.                     tmp13 = tmp0 - tmp3;
  2429.                     tmp11 = tmp1 + tmp2;
  2430.                     tmp12 = tmp1 - tmp2;
  2431.                 } else {
  2432.                     /* d0 == 0, d2 != 0, d4 != 0, d6 != 0 */
  2433.                     z1 = MULTIPLY(d2 + d6, FIX(0.541196100));
  2434.                     tmp2 = z1 + MULTIPLY(d6, - FIX(1.847759065));
  2435.                     tmp3 = z1 + MULTIPLY(d2, FIX(0.765366865));
  2436.  
  2437.                     tmp0 = d4 << CONST_BITS;
  2438.  
  2439.                     tmp10 = tmp0 + tmp3;
  2440.                     tmp13 = tmp0 - tmp3;
  2441.                     tmp11 = tmp2 - tmp0;
  2442.                     tmp12 = -(tmp0 + tmp2);
  2443.                 }
  2444.             } else {
  2445.                 if (d0) {
  2446.                     /* d0 != 0, d2 == 0, d4 != 0, d6 != 0 */
  2447.                     tmp2 = MULTIPLY(d6, - FIX(1.306562965));
  2448.                     tmp3 = MULTIPLY(d6, FIX(0.541196100));
  2449.  
  2450.                     tmp0 = (d0 + d4) << CONST_BITS;
  2451.                     tmp1 = (d0 - d4) << CONST_BITS;
  2452.  
  2453.                     tmp10 = tmp0 + tmp3;
  2454.                     tmp13 = tmp0 - tmp3;
  2455.                     tmp11 = tmp1 + tmp2;
  2456.                     tmp12 = tmp1 - tmp2;
  2457.                 } else {
  2458.                     /* d0 == 0, d2 == 0, d4 != 0, d6 != 0 */
  2459.                     tmp2 = MULTIPLY(d6, -FIX(1.306562965));
  2460.                     tmp3 = MULTIPLY(d6, FIX(0.541196100));
  2461.  
  2462.                     tmp0 = d4 << CONST_BITS;
  2463.  
  2464.                     tmp10 = tmp0 + tmp3;
  2465.                     tmp13 = tmp0 - tmp3;
  2466.                     tmp11 = tmp2 - tmp0;
  2467.                     tmp12 = -(tmp0 + tmp2);
  2468.                 }
  2469.             }
  2470.         } else {
  2471.             if (d2) {
  2472.                 if (d0) {
  2473.                     /* d0 != 0, d2 != 0, d4 == 0, d6 != 0 */
  2474.                     z1 = MULTIPLY(d2 + d6, FIX(0.541196100));
  2475.                     tmp2 = z1 + MULTIPLY(d6, - FIX(1.847759065));
  2476.                     tmp3 = z1 + MULTIPLY(d2, FIX(0.765366865));
  2477.  
  2478.                     tmp0 = d0 << CONST_BITS;
  2479.  
  2480.                     tmp10 = tmp0 + tmp3;
  2481.                     tmp13 = tmp0 - tmp3;
  2482.                     tmp11 = tmp0 + tmp2;
  2483.                     tmp12 = tmp0 - tmp2;
  2484.                 } else {
  2485.                     /* d0 == 0, d2 != 0, d4 == 0, d6 != 0 */
  2486.                     z1 = MULTIPLY(d2 + d6, FIX(0.541196100));
  2487.                     tmp2 = z1 + MULTIPLY(d6, - FIX(1.847759065));
  2488.                     tmp3 = z1 + MULTIPLY(d2, FIX(0.765366865));
  2489.  
  2490.                     tmp10 = tmp3;
  2491.                     tmp13 = -tmp3;
  2492.                     tmp11 = tmp2;
  2493.                     tmp12 = -tmp2;
  2494.                 }
  2495.             } else {
  2496.                 if (d0) {
  2497.                     /* d0 != 0, d2 == 0, d4 == 0, d6 != 0 */
  2498.                     tmp2 = MULTIPLY(d6, - FIX(1.306562965));
  2499.                     tmp3 = MULTIPLY(d6, FIX(0.541196100));
  2500.  
  2501.                     tmp0 = d0 << CONST_BITS;
  2502.  
  2503.                     tmp10 = tmp0 + tmp3;
  2504.                     tmp13 = tmp0 - tmp3;
  2505.                     tmp11 = tmp0 + tmp2;
  2506.                     tmp12 = tmp0 - tmp2;
  2507.                 } else {
  2508.                     /* d0 == 0, d2 == 0, d4 == 0, d6 != 0 */
  2509.                     tmp2 = MULTIPLY(d6, - FIX(1.306562965));
  2510.                     tmp3 = MULTIPLY(d6, FIX(0.541196100));
  2511.  
  2512.                     tmp10 = tmp3;
  2513.                     tmp13 = -tmp3;
  2514.                     tmp11 = tmp2;
  2515.                     tmp12 = -tmp2;
  2516.                 }
  2517.             }
  2518.         }
  2519.     } else {
  2520.         if (d4) {
  2521.             if (d2) {
  2522.                 if (d0) {
  2523.                     /* d0 != 0, d2 != 0, d4 != 0, d6 == 0 */
  2524.                     tmp2 = MULTIPLY(d2, FIX(0.541196100));
  2525.                     tmp3 = MULTIPLY(d2, FIX(1.306562965));
  2526.  
  2527.                     tmp0 = (d0 + d4) << CONST_BITS;
  2528.                     tmp1 = (d0 - d4) << CONST_BITS;
  2529.  
  2530.                     tmp10 = tmp0 + tmp3;
  2531.                     tmp13 = tmp0 - tmp3;
  2532.                     tmp11 = tmp1 + tmp2;
  2533.                     tmp12 = tmp1 - tmp2;
  2534.                 } else {
  2535.                     /* d0 == 0, d2 != 0, d4 != 0, d6 == 0 */
  2536.                     tmp2 = MULTIPLY(d2, FIX(0.541196100));
  2537.                     tmp3 = MULTIPLY(d2, FIX(1.306562965));
  2538.  
  2539.                     tmp0 = d4 << CONST_BITS;
  2540.  
  2541.                     tmp10 = tmp0 + tmp3;
  2542.                     tmp13 = tmp0 - tmp3;
  2543.                     tmp11 = tmp2 - tmp0;
  2544.                     tmp12 = -(tmp0 + tmp2);
  2545.                 }
  2546.             } else {
  2547.                 if (d0) {
  2548.                     /* d0 != 0, d2 == 0, d4 != 0, d6 == 0 */
  2549.                     tmp10 = tmp13 = (d0 + d4) << CONST_BITS;
  2550.                     tmp11 = tmp12 = (d0 - d4) << CONST_BITS;
  2551.                 } else {
  2552.                     /* d0 == 0, d2 == 0, d4 != 0, d6 == 0 */
  2553.                     tmp10 = tmp13 = d4 << CONST_BITS;
  2554.                     tmp11 = tmp12 = -tmp10;
  2555.                 }
  2556.             }
  2557.         } else {
  2558.             if (d2) {
  2559.                 if (d0) {
  2560.                     /* d0 != 0, d2 != 0, d4 == 0, d6 == 0 */
  2561.                     tmp2 = MULTIPLY(d2, FIX(0.541196100));
  2562.                     tmp3 = MULTIPLY(d2, FIX(1.306562965));
  2563.  
  2564.                     tmp0 = d0 << CONST_BITS;
  2565.  
  2566.                     tmp10 = tmp0 + tmp3;
  2567.                     tmp13 = tmp0 - tmp3;
  2568.                     tmp11 = tmp0 + tmp2;
  2569.                     tmp12 = tmp0 - tmp2;
  2570.                 } else {
  2571.                     /* d0 == 0, d2 != 0, d4 == 0, d6 == 0 */
  2572.                     tmp2 = MULTIPLY(d2, FIX(0.541196100));
  2573.                     tmp3 = MULTIPLY(d2, FIX(1.306562965));
  2574.  
  2575.                     tmp10 = tmp3;
  2576.                     tmp13 = -tmp3;
  2577.                     tmp11 = tmp2;
  2578.                     tmp12 = -tmp2;
  2579.                 }
  2580.             } else {
  2581.                 if (d0) {
  2582.                     /* d0 != 0, d2 == 0, d4 == 0, d6 == 0 */
  2583.                     tmp10 = tmp13 = tmp11 = tmp12 = d0 << CONST_BITS;
  2584.                 } else {
  2585.                     /* d0 == 0, d2 == 0, d4 == 0, d6 == 0 */
  2586.                     tmp10 = tmp13 = tmp11 = tmp12 = 0;
  2587.                 }
  2588.             }
  2589.         }
  2590.     }
  2591.  
  2592.     /* Odd part per figure 8; the matrix is unitary and hence its
  2593.      * transpose is its inverse.  i0..i3 are y7,y5,y3,y1 respectively.
  2594.      */
  2595.     if (d7) {
  2596.         if (d5) {
  2597.             if (d3) {
  2598.                 if (d1) {
  2599.                     /* d1 != 0, d3 != 0, d5 != 0, d7 != 0 */
  2600.                     z1 = d7 + d1;
  2601.                     z2 = d5 + d3;
  2602.                     z3 = d7 + d3;
  2603.                     z4 = d5 + d1;
  2604.                     z5 = MULTIPLY(z3 + z4, FIX(1.175875602));
  2605.  
  2606.                     tmp0 = MULTIPLY(d7, FIX(0.298631336));
  2607.                     tmp1 = MULTIPLY(d5, FIX(2.053119869));
  2608.                     tmp2 = MULTIPLY(d3, FIX(3.072711026));
  2609.                     tmp3 = MULTIPLY(d1, FIX(1.501321110));
  2610.                     z1 = MULTIPLY(z1, - FIX(0.899976223));
  2611.                     z2 = MULTIPLY(z2, - FIX(2.562915447));
  2612.                     z3 = MULTIPLY(z3, - FIX(1.961570560));
  2613.                     z4 = MULTIPLY(z4, - FIX(0.390180644));
  2614.  
  2615.                     z3 += z5;
  2616.                     z4 += z5;
  2617.  
  2618.                     tmp0 += z1 + z3;
  2619.                     tmp1 += z2 + z4;
  2620.                     tmp2 += z2 + z3;
  2621.                     tmp3 += z1 + z4;
  2622.                 } else {
  2623.                     /* d1 == 0, d3 != 0, d5 != 0, d7 != 0 */
  2624.                     z1 = d7;
  2625.                     z2 = d5 + d3;
  2626.                     z3 = d7 + d3;
  2627.                     z5 = MULTIPLY(z3 + d5, FIX(1.175875602));
  2628.  
  2629.                     tmp0 = MULTIPLY(d7, FIX(0.298631336));
  2630.                     tmp1 = MULTIPLY(d5, FIX(2.053119869));
  2631.                     tmp2 = MULTIPLY(d3, FIX(3.072711026));
  2632.                     z1 = MULTIPLY(d7, - FIX(0.899976223));
  2633.                     z2 = MULTIPLY(z2, - FIX(2.562915447));
  2634.                     z3 = MULTIPLY(z3, - FIX(1.961570560));
  2635.                     z4 = MULTIPLY(d5, - FIX(0.390180644));
  2636.  
  2637.                     z3 += z5;
  2638.                     z4 += z5;
  2639.  
  2640.                     tmp0 += z1 + z3;
  2641.                     tmp1 += z2 + z4;
  2642.                     tmp2 += z2 + z3;
  2643.                     tmp3 = z1 + z4;
  2644.                 }
  2645.             } else {
  2646.                 if (d1) {
  2647.                     /* d1 != 0, d3 == 0, d5 != 0, d7 != 0 */
  2648.                     z1 = d7 + d1;
  2649.                     z2 = d5;
  2650.                     z3 = d7;
  2651.                     z4 = d5 + d1;
  2652.                     z5 = MULTIPLY(z3 + z4, FIX(1.175875602));
  2653.  
  2654.                     tmp0 = MULTIPLY(d7, FIX(0.298631336));
  2655.                     tmp1 = MULTIPLY(d5, FIX(2.053119869));
  2656.                     tmp3 = MULTIPLY(d1, FIX(1.501321110));
  2657.                     z1 = MULTIPLY(z1, - FIX(0.899976223));
  2658.                     z2 = MULTIPLY(d5, - FIX(2.562915447));
  2659.                     z3 = MULTIPLY(d7, - FIX(1.961570560));
  2660.                     z4 = MULTIPLY(z4, - FIX(0.390180644));
  2661.  
  2662.                     z3 += z5;
  2663.                     z4 += z5;
  2664.  
  2665.                     tmp0 += z1 + z3;
  2666.                     tmp1 += z2 + z4;
  2667.                     tmp2 = z2 + z3;
  2668.                     tmp3 += z1 + z4;
  2669.                 } else {
  2670.                     /* d1 == 0, d3 == 0, d5 != 0, d7 != 0 */
  2671.                     tmp0 = MULTIPLY(d7, - FIX(0.601344887));
  2672.                     z1 = MULTIPLY(d7, - FIX(0.899976223));
  2673.                     z3 = MULTIPLY(d7, - FIX(1.961570560));
  2674.                     tmp1 = MULTIPLY(d5, - FIX(0.509795578));
  2675.                     z2 = MULTIPLY(d5, - FIX(2.562915447));
  2676.                     z4 = MULTIPLY(d5, - FIX(0.390180644));
  2677.                     z5 = MULTIPLY(d5 + d7, FIX(1.175875602));
  2678.  
  2679.                     z3 += z5;
  2680.                     z4 += z5;
  2681.  
  2682.                     tmp0 += z3;
  2683.                     tmp1 += z4;
  2684.                     tmp2 = z2 + z3;
  2685.                     tmp3 = z1 + z4;
  2686.                 }
  2687.             }
  2688.         } else {
  2689.             if (d3) {
  2690.                 if (d1) {
  2691.                     /* d1 != 0, d3 != 0, d5 == 0, d7 != 0 */
  2692.                     z1 = d7 + d1;
  2693.                     z3 = d7 + d3;
  2694.                     z5 = MULTIPLY(z3 + d1, FIX(1.175875602));
  2695.  
  2696.                     tmp0 = MULTIPLY(d7, FIX(0.298631336));
  2697.                     tmp2 = MULTIPLY(d3, FIX(3.072711026));
  2698.                     tmp3 = MULTIPLY(d1, FIX(1.501321110));
  2699.                     z1 = MULTIPLY(z1, - FIX(0.899976223));
  2700.                     z2 = MULTIPLY(d3, - FIX(2.562915447));
  2701.                     z3 = MULTIPLY(z3, - FIX(1.961570560));
  2702.                     z4 = MULTIPLY(d1, - FIX(0.390180644));
  2703.  
  2704.                     z3 += z5;
  2705.                     z4 += z5;
  2706.  
  2707.                     tmp0 += z1 + z3;
  2708.                     tmp1 = z2 + z4;
  2709.                     tmp2 += z2 + z3;
  2710.                     tmp3 += z1 + z4;
  2711.                 } else {
  2712.                     /* d1 == 0, d3 != 0, d5 == 0, d7 != 0 */
  2713.                     z3 = d7 + d3;
  2714.  
  2715.                     tmp0 = MULTIPLY(d7, - FIX(0.601344887));
  2716.                     z1 = MULTIPLY(d7, - FIX(0.899976223));
  2717.                     tmp2 = MULTIPLY(d3, FIX(0.509795579));
  2718.                     z2 = MULTIPLY(d3, - FIX(2.562915447));
  2719.                     z5 = MULTIPLY(z3, FIX(1.175875602));
  2720.                     z3 = MULTIPLY(z3, - FIX(0.785694958));
  2721.  
  2722.                     tmp0 += z3;
  2723.                     tmp1 = z2 + z5;
  2724.                     tmp2 += z3;
  2725.                     tmp3 = z1 + z5;
  2726.                 }
  2727.             } else {
  2728.                 if (d1) {
  2729.                     /* d1 != 0, d3 == 0, d5 == 0, d7 != 0 */
  2730.                     z1 = d7 + d1;
  2731.                     z5 = MULTIPLY(z1, FIX(1.175875602));
  2732.  
  2733.                     z1 = MULTIPLY(z1, FIX(0.275899379));
  2734.                     z3 = MULTIPLY(d7, - FIX(1.961570560));
  2735.                     tmp0 = MULTIPLY(d7, - FIX(1.662939224));
  2736.                     z4 = MULTIPLY(d1, - FIX(0.390180644));
  2737.                     tmp3 = MULTIPLY(d1, FIX(1.111140466));
  2738.  
  2739.                     tmp0 += z1;
  2740.                     tmp1 = z4 + z5;
  2741.                     tmp2 = z3 + z5;
  2742.                     tmp3 += z1;
  2743.                 } else {
  2744.                     /* d1 == 0, d3 == 0, d5 == 0, d7 != 0 */
  2745.                     tmp0 = MULTIPLY(d7, - FIX(1.387039845));
  2746.                     tmp1 = MULTIPLY(d7, FIX(1.175875602));
  2747.                     tmp2 = MULTIPLY(d7, - FIX(0.785694958));
  2748.                     tmp3 = MULTIPLY(d7, FIX(0.275899379));
  2749.                 }
  2750.             }
  2751.         }
  2752.     } else {
  2753.         if (d5) {
  2754.             if (d3) {
  2755.                 if (d1) {
  2756.                     /* d1 != 0, d3 != 0, d5 != 0, d7 == 0 */
  2757.                     z2 = d5 + d3;
  2758.                     z4 = d5 + d1;
  2759.                     z5 = MULTIPLY(d3 + z4, FIX(1.175875602));
  2760.  
  2761.                     tmp1 = MULTIPLY(d5, FIX(2.053119869));
  2762.                     tmp2 = MULTIPLY(d3, FIX(3.072711026));
  2763.                     tmp3 = MULTIPLY(d1, FIX(1.501321110));
  2764.                     z1 = MULTIPLY(d1, - FIX(0.899976223));
  2765.                     z2 = MULTIPLY(z2, - FIX(2.562915447));
  2766.                     z3 = MULTIPLY(d3, - FIX(1.961570560));
  2767.                     z4 = MULTIPLY(z4, - FIX(0.390180644));
  2768.  
  2769.                     z3 += z5;
  2770.                     z4 += z5;
  2771.  
  2772.                     tmp0 = z1 + z3;
  2773.                     tmp1 += z2 + z4;
  2774.                     tmp2 += z2 + z3;
  2775.                     tmp3 += z1 + z4;
  2776.                 } else {
  2777.                     /* d1 == 0, d3 != 0, d5 != 0, d7 == 0 */
  2778.                     z2 = d5 + d3;
  2779.  
  2780.                     z5 = MULTIPLY(z2, FIX(1.175875602));
  2781.                     tmp1 = MULTIPLY(d5, FIX(1.662939225));
  2782.                     z4 = MULTIPLY(d5, - FIX(0.390180644));
  2783.                     z2 = MULTIPLY(z2, - FIX(1.387039845));
  2784.                     tmp2 = MULTIPLY(d3, FIX(1.111140466));
  2785.                     z3 = MULTIPLY(d3, - FIX(1.961570560));
  2786.  
  2787.                     tmp0 = z3 + z5;
  2788.                     tmp1 += z2;
  2789.                     tmp2 += z2;
  2790.                     tmp3 = z4 + z5;
  2791.                 }
  2792.             } else {
  2793.                 if (d1) {
  2794.                     /* d1 != 0, d3 == 0, d5 != 0, d7 == 0 */
  2795.                     z4 = d5 + d1;
  2796.  
  2797.                     z5 = MULTIPLY(z4, FIX(1.175875602));
  2798.                     z1 = MULTIPLY(d1, - FIX(0.899976223));
  2799.                     tmp3 = MULTIPLY(d1, FIX(0.601344887));
  2800.                     tmp1 = MULTIPLY(d5, - FIX(0.509795578));
  2801.                     z2 = MULTIPLY(d5, - FIX(2.562915447));
  2802.                     z4 = MULTIPLY(z4, FIX(0.785694958));
  2803.  
  2804.                     tmp0 = z1 + z5;
  2805.                     tmp1 += z4;
  2806.                     tmp2 = z2 + z5;
  2807.                     tmp3 += z4;
  2808.                 } else {
  2809.                     /* d1 == 0, d3 == 0, d5 != 0, d7 == 0 */
  2810.                     tmp0 = MULTIPLY(d5, FIX(1.175875602));
  2811.                     tmp1 = MULTIPLY(d5, FIX(0.275899380));
  2812.                     tmp2 = MULTIPLY(d5, - FIX(1.387039845));
  2813.                     tmp3 = MULTIPLY(d5, FIX(0.785694958));
  2814.                 }
  2815.             }
  2816.         } else {
  2817.             if (d3) {
  2818.                 if (d1) {
  2819.                     /* d1 != 0, d3 != 0, d5 == 0, d7 == 0 */
  2820.                     z5 = d1 + d3;
  2821.                     tmp3 = MULTIPLY(d1, FIX(0.211164243));
  2822.                     tmp2 = MULTIPLY(d3, - FIX(1.451774981));
  2823.                     z1 = MULTIPLY(d1, FIX(1.061594337));
  2824.                     z2 = MULTIPLY(d3, - FIX(2.172734803));
  2825.                     z4 = MULTIPLY(z5, FIX(0.785694958));
  2826.                     z5 = MULTIPLY(z5, FIX(1.175875602));
  2827.  
  2828.                     tmp0 = z1 - z4;
  2829.                     tmp1 = z2 + z4;
  2830.                     tmp2 += z5;
  2831.                     tmp3 += z5;
  2832.                 } else {
  2833.                     /* d1 == 0, d3 != 0, d5 == 0, d7 == 0 */
  2834.                     tmp0 = MULTIPLY(d3, - FIX(0.785694958));
  2835.                     tmp1 = MULTIPLY(d3, - FIX(1.387039845));
  2836.                     tmp2 = MULTIPLY(d3, - FIX(0.275899379));
  2837.                     tmp3 = MULTIPLY(d3, FIX(1.175875602));
  2838.                 }
  2839.             } else {
  2840.                 if (d1) {
  2841.                     /* d1 != 0, d3 == 0, d5 == 0, d7 == 0 */
  2842.                     tmp0 = MULTIPLY(d1, FIX(0.275899379));
  2843.                     tmp1 = MULTIPLY(d1, FIX(0.785694958));
  2844.                     tmp2 = MULTIPLY(d1, FIX(1.175875602));
  2845.                     tmp3 = MULTIPLY(d1, FIX(1.387039845));
  2846.                 } else {
  2847.                     /* d1 == 0, d3 == 0, d5 == 0, d7 == 0 */
  2848.                     tmp0 = tmp1 = tmp2 = tmp3 = 0;
  2849.                 }
  2850.             }
  2851.         }
  2852.     }
  2853.  
  2854.     /* Final output stage: inputs are tmp10..tmp13, tmp0..tmp3 */
  2855.  
  2856.  
  2857.     outptr[DCTSIZE*0] = limit[ (int) DESCALE(tmp10 + tmp3,
  2858.                                 CONST_BITS+PASS1_BITS+3) & RANGE_MASK];
  2859.     outptr[DCTSIZE*7] = limit[ (int) DESCALE(tmp10 - tmp3,
  2860.                                 CONST_BITS+PASS1_BITS+3) & RANGE_MASK];
  2861.     outptr[DCTSIZE*1] = limit[ (int) DESCALE(tmp11 + tmp2,
  2862.                                 CONST_BITS+PASS1_BITS+3) & RANGE_MASK];
  2863.     outptr[DCTSIZE*6] = limit[ (int) DESCALE(tmp11 - tmp2,
  2864.                                 CONST_BITS+PASS1_BITS+3) & RANGE_MASK];
  2865.     outptr[DCTSIZE*2] = limit[ (int) DESCALE(tmp12 + tmp1,
  2866.                                 CONST_BITS+PASS1_BITS+3) & RANGE_MASK];
  2867.     outptr[DCTSIZE*5] = limit[ (int) DESCALE(tmp12 - tmp1,
  2868.                                 CONST_BITS+PASS1_BITS+3) & RANGE_MASK];
  2869.     outptr[DCTSIZE*3] = limit[ (int) DESCALE(tmp13 + tmp0,
  2870.                                 CONST_BITS+PASS1_BITS+3) & RANGE_MASK];
  2871.     outptr[DCTSIZE*4] = limit[ (int) DESCALE(tmp13 - tmp0,
  2872.                                 CONST_BITS+PASS1_BITS+3) & RANGE_MASK];
  2873.  
  2874.     dataptr++;                  /* advance pointer to next column */
  2875.     outptr++;
  2876.   }
  2877. }
  2878. /* \\\ */
  2879.  
  2880. /* /// "SelectJPEGFuncs()" */
  2881. __asm void SelectJPEGFuncs(REG(a0) struct JPEGData *spec,
  2882.                            REG(d0) uchar _gray,
  2883.                            REG(d1) uchar _dither)
  2884. {
  2885.   ulong x;
  2886.  
  2887.   JPGData=spec;
  2888.   for (x=0; x<JJ_NUM_QUANT_TBLS; x++) jpg_quant_tables[x]=spec->quantTab[x];
  2889.   if (_gray) {
  2890.     mcu111111=MCU111111to332;
  2891.     mcu211111=MCU211111to332;
  2892.     mcu221111=MCU221111to332;
  2893.     mcu411111=MCU411111to332;
  2894.     bytes_pixel=1;
  2895.   } else if (_dither) {
  2896.     mcu111111=MCU111111to332Dith;
  2897.     mcu211111=MCU211111to332Dith;
  2898.     mcu221111=MCU221111to332Dith;
  2899.     mcu411111=MCU411111to332Dith;
  2900.     bytes_pixel=1;
  2901.   } else {
  2902.     mcu111111=MCU111111toRGB;
  2903.     mcu211111=MCU211111toRGB;
  2904.     mcu221111=MCU221111toRGB;
  2905.     mcu411111=MCU411111toRGB;
  2906.     bytes_pixel=4;
  2907.   }
  2908. }
  2909. /* \\\ */
  2910.  
  2911. /* /// "DecodeJPEG()" */
  2912. __asm void DecodeJPEG(REG(a0) uchar *delta,
  2913.                       REG(a1) uchar *image,
  2914.                       REG(d0) ulong myWidth,
  2915.                       REG(d1) ulong myHeight,
  2916.                       REG(d2) ulong dsize,
  2917.                       REG(a2) struct JPEGData *spec)
  2918. {
  2919.   ulong imagex = myWidth;
  2920.   ulong imagey = myHeight;
  2921.   // void *extra = dec_info->extra;
  2922.   long base_y;
  2923.   ulong jpg_type;
  2924.   ulong interleave,row_offset;
  2925.  
  2926.   // jpg_type = (ulong)(extra);
  2927.   jpg_type=0x00;
  2928.   // xa_mjpg_kludge = (jpg_type & 0x40)?(0x40):(0x00);
  2929.   xa_mjpg_kludge=0x00;
  2930.  
  2931. /* init buffer stuff */
  2932.   jpg_init_input(delta,dsize);
  2933.  
  2934.   base_y = 0;
  2935.   while(base_y < imagey)
  2936.   {
  2937.     jpg_saw_EOI = jpg_saw_DHT = xaFALSE;
  2938.     // hier war der ganze IJPG-Kram
  2939.     {
  2940.       /* read markers */
  2941.       jpg_saw_SOI = jpg_saw_SOF = jpg_saw_SOS = jpg_saw_DHT = jpg_saw_DQT = xaFALSE;
  2942.       if (jpg_read_markers() == xaFALSE) {
  2943.         // jpg_free_stuff();
  2944.         // kprintf("JPG: rd marker err\n");
  2945.         return;
  2946.       }
  2947.       jpg_huff_reset();
  2948.  
  2949.       interleave = (jpg_height <= ((imagey>>1)+1) )?(2):(1);
  2950.       row_offset = ((interleave == 2) && (base_y == 0))?(1):(0);
  2951.     }
  2952.     jpg_marker = 0x00;
  2953.     // if (jpg_width > imagex) JPG_Alloc_MCU_Bufs(0,jpg_width,0,xaFALSE);
  2954.  
  2955.  
  2956.     if ((jpg_saw_DHT != xaTRUE) && (jpg_std_DHT_flag==0))
  2957.     {
  2958.       // DEBUG_LEVEL1 kprintf("standard DHT tables\n");
  2959.       jpg_std_DHT();
  2960.     }
  2961.     // DEBUG_LEVEL1 kprintf("JJ: imagexy %d %d  jjxy %d %d basey %d\n",imagex,imagey,jpg_width,jpg_height,base_y);
  2962.  
  2963.     if (   (jpg_num_comps == 3) && (jpg_comps_in_scan == 3)
  2964.         && (jpg_comps[1].hvsample == 0x11) && (jpg_comps[2].hvsample== 0x11) )
  2965.     {
  2966.       if (jpg_comps[0].hvsample == 0x41) /* 411 */
  2967.         { jpg_decode_411111(image,jpg_width,jpg_height,interleave,row_offset,
  2968.                         imagex,imagey); }
  2969.       else if (jpg_comps[0].hvsample == 0x22) /* 221 */
  2970.         { jpg_decode_221111(image,jpg_width,jpg_height,interleave,row_offset,
  2971.                         imagex,imagey); }
  2972.       else if (jpg_comps[0].hvsample == 0x21) /* 211 */
  2973.         { jpg_decode_211111(image,jpg_width,jpg_height,interleave,row_offset,
  2974.                         imagex,imagey); }
  2975.       else if (jpg_comps[0].hvsample == 0x11) /* 111 */
  2976.         { jpg_decode_111111(image,jpg_width,jpg_height,interleave,row_offset,
  2977.                         imagex,imagey,0); }
  2978.       else
  2979.       { // kprintf("JPG: cmps %d %d mcu %04x %04x %04x unsupported\n",
  2980.         //         jpg_num_comps,jpg_comps_in_scan,jpg_comps[0].hvsample,
  2981.         //         jpg_comps[1].hvsample,jpg_comps[2].hvsample);
  2982.         break;
  2983.       }
  2984.     }
  2985.     else if ( (jpg_num_comps == 1) || (jpg_comps_in_scan == 1) )
  2986.     {
  2987.       jpg_decode_111111(image,jpg_width,jpg_height,interleave,row_offset,
  2988.                         imagex,imagey,1);
  2989.     }
  2990.     else
  2991.     { // kprintf("JPG: cmps %d %d mcu %04x %04x %04x unsupported.\n",
  2992.       //           jpg_num_comps,jpg_comps_in_scan,jpg_comps[0].hvsample,
  2993.       //           jpg_comps[1].hvsample,jpg_comps[2].hvsample);
  2994.       break;
  2995.     }
  2996.  
  2997.     base_y += ((interleave == 1)?(imagey):(jpg_height));
  2998.     if (jpg_marker == M_EOI) { jpg_saw_EOI = xaTRUE; jpg_marker = 0x00; }
  2999.     else if (jpg_saw_EOI==xaFALSE) if (jpg_read_EOI_marker() == xaFALSE) break;
  3000.   }
  3001.   return;
  3002. }
  3003. /* \\\ */
  3004.  
  3005.